C++ TextReader::GetNextToken方法代码示例

void Gesture::LoadTrainingData( char *filename )
{
    TextReader *reader = g_app->m_resource->GetTextReader(filename);
    DarwiniaReleaseAssert(reader && reader->IsOpen(), "Couldn't open Gesture data file");

	reader->ReadLine();
    int numSymbols = atoi(reader->GetNextToken());
    m_symbols.SetSize( numSymbols );

    for( int c = 0; c < numSymbols; ++c )
    {
        m_symbols.PutData( GestureSymbol(), c );
        Classification *theClass = &m_symbols[c].m_classes;

		reader->ReadLine();
        theClass->m_nextTrainer = atoi(reader->GetNextToken());
		if( theClass->m_nextTrainer > 0 )
        {
            reader->ReadLine();
            for( int t = 0; t < theClass->m_nextTrainer; ++t )
            {
                FeatureSet *fs = &theClass->m_trainers[t];
                for( int f = 0; f <= GESTURE_MAX_FEATURES; ++f )
                {
                    fs->f[f] = atof(reader->GetNextToken());
                }
            }
        }
    }

    delete reader;

    TrainSystem();
}

void EntityBlueprint::Initialise()
{
	TextReader *theFile = g_app->m_resource->GetTextReader("stats.txt");
	AppReleaseAssert(theFile && theFile->IsOpen(), "Couldn't open stats.txt");

    int entityIndex = 0;

    while( theFile->ReadLine() )
    {
		if (!theFile->TokenAvailable()) continue;		
        AppReleaseAssert(entityIndex < Entity::NumEntityTypes, "Too many entity blueprints defined");
		
        m_names[entityIndex] = strdup(theFile->GetNextToken());
		m_stats[entityIndex][0] = iv_atof(theFile->GetNextToken());
        m_stats[entityIndex][1] = iv_atof(theFile->GetNextToken());
        m_stats[entityIndex][2] = iv_atof(theFile->GetNextToken());

        ++entityIndex;
    }

	delete theFile;
}

bool LanguageTable::LoadLanguageCaption( Language *lang )
{
    TextReader *in = g_fileSystem->GetTextReader( lang->m_path );

	if( !in ) return false;

	if( !in->IsOpen() )
	{
		delete in;
		return false;
	}

    //
	// Read all the phrases from the language file

	while (in->ReadLine())
	{
		if (!in->TokenAvailable()) continue;

		char *key = in->GetNextToken();

		char *aString = in->GetRestOfLine();

		if( key && aString && stricmp( key, "lang" ) == 0 )
		{
			//
			// Strip trailing '\n'
	        
			int stringLength = strlen( aString );
			if( aString[stringLength-1] == '\n' ) 
			{
				aString[stringLength-1] = '\x0';
			}

			if( aString[stringLength-2] == '\r' )
			{
				aString[stringLength-2] = '\x0';
			}

			snprintf( lang->m_caption, sizeof(lang->m_caption), aString );
			lang->m_caption[ sizeof(lang->m_caption) - 1 ] = '\0';

			delete in;
			return true;
		}
	}

    delete in;
	return false;
}

void LanguageTable::LoadLanguage(char *_filename, BTree<char *> &_langTable )
{
    TextReader *in = g_fileSystem->GetTextReader(_filename);
	AppReleaseAssert(in && in->IsOpen(), "Couldn't open language file %s", _filename );

    //
	// Read all the phrases from the language file

	while (in->ReadLine())
	{
		if (!in->TokenAvailable()) continue;

		char *key = in->GetNextToken();	


#ifdef TARGET_OS_MACOSX
        // 
        // Special case hack
        // If this is the Mac version and there is a replacement string
        // Use the replacement string instead
        #define MACOSX_MARKER "macosx_"
        if( strncmp( key, MACOSX_MARKER, strlen(MACOSX_MARKER) ) == 0 )
        {
            key += strlen(MACOSX_MARKER);
        }
#endif


        //
		// Make sure the this key isn't already used

		if(_langTable.LookupTree(key))
        {
            //AppDebugOut( "Warning : found duplicate key '%s' in language file %s\n", key, _filename );
            _langTable.RemoveData( key );
        }

		char *aString = strdup( in->GetRestOfLine() ); 
        
        //
		// Make sure a language key always has a some text with it

		if( !aString || aString[0] == '\0' )
		{
            AppDebugOut( "Warning : found key '%s' with no translation in language file %s\n", key, _filename );

			if( aString )
			{
				delete [] aString;
			}
			continue;
		}

        //
        // Convert the string "\n" into a genuine '\n'

        for( unsigned int i = 0; i < strlen(aString)-1; ++i )
        {
            if( aString[i] == '\\' && aString[i+1] == 'n' )
            {
                aString[i] = ' ';
                aString[i+1] = '\n';
            }
        }
        
        //
        // Strip trailing '\n'
        
        int stringLength = strlen( aString );
        if( aString[stringLength-1] == '\n' ) 
        {
            aString[stringLength-1] = '\x0';
        }

        if( aString[stringLength-2] == '\r' )
        {
            aString[stringLength-2] = '\x0';
        }

		_langTable.PutData(key, aString);
	}

    delete in;
}

void InputManager::parseInputPrefs( TextReader &reader, bool replace )
{
	int line = 1;
	// FIXME: always log to file on OS X, not to Console, because we're getting
	// a number of spurious error messages.
#if defined(TARGET_OS_MACOSX) || defined(TARGET_DEBUG) 
	char fullFileName[512];
	snprintf( fullFileName, sizeof(fullFileName), "%sinputprefs_debug.txt", g_app->GetProfileDirectory() );
	fullFileName[ sizeof(fullFileName) - 1 ] = '\0';
	ofstream derr( fullFileName );
#else
	ostream &derr = cout;
#endif

	while ( reader.ReadLine() ) {
		// derr << "Line " << line++ << ": ";
		bool iconline = false;
		char *control = reader.GetNextToken();
		if ( control ) {
			char *eq = reader.GetNextToken();
			if ( !eq || strcmp( eq, "=" ) != 0 ) {
				if ( eq && !strcmp( eq, "~" ) ) {
					iconline = true;
				} else {
					derr << "Assignment not found." << endl;
					continue;
				}
			}

			string inputspec = reader.GetRestOfLine();
			controltype_t control_id = getControlID( control );
			if ( control_id >= 0 ) {

				if ( iconline ) {
					if ( inputspec != "" ) {
						unsigned len = inputspec.length() - 1;
						if ( inputspec[ len ] == '\n' )
							inputspec = inputspec.substr( 0, len-- );
						if ( inputspec[ len ] == '\r' )
							inputspec = inputspec.substr( 0, len );
						bindings.setIcon( control_id, inputspec );						
					} else
						derr << "Empty icon line." << endl;
					continue;
				}

				InputSpec spec;
				string err;
				InputParserState state;

				if ( PARSE_SUCCESS( state = parseInputSpecString( inputspec, spec, err ) ) ) {
					if ( !bindings.bind( control_id, spec, replace ) )
						derr << "Binding failed." << endl;
				} 
				else 
				{
					derr << "Parse failed - " << err << " (state = " << state << ")" << endl;
				}
			} else derr << "Control ID not found." << endl;

		} 
	}
}

Game::Game()
:   m_victoryTimer(-1),
    m_recalcTimer(0),
    m_winner(-1),
    m_maxGameTime(-1),
    m_gameTimeWarning(false),
    m_lockVictoryTimer(false),
    m_lastKnownDefcon(5),
    m_gameMode(-1)
{
    //
    // Load game options
    
    TextReader *in = g_fileSystem->GetTextReader( "data/gameoptions.txt" );
	AppAssert(in && in->IsOpen());

    while( in->ReadLine() )
    {
        if( !in->TokenAvailable() ) continue;

        char *param = in->GetNextToken();

        GameOption *option = new GameOption();
        m_options.PutData( option );

        strcpy( option->m_name,     param );
        option->m_min       = atof( in->GetNextToken() );
        option->m_max       = atof( in->GetNextToken() );
        option->m_default   = atof( in->GetNextToken() );
        option->m_change    = atoi( in->GetNextToken() );     
        
        if( option->m_change == 0 )
        {
            // Drop down menu - so load the sub options
            int numOptions = option->m_max - option->m_min;
            numOptions ++;
            for( int i = 0; i < numOptions; ++i )
            {
                in->ReadLine();
                char *subOption = strdup( in->GetRestOfLine() );
                
                // Strip trailing \n and \r
                int stringLength = strlen(subOption);
                if( subOption[stringLength-1] == '\n' ) subOption[stringLength-1] = '\x0';                
                if( subOption[stringLength-2] == '\r' ) subOption[stringLength-2] = '\x0';
                
                option->m_subOptions.PutData( subOption );
            }
        }

        if( option->m_change == -1 )
        {
            // String - load default
            in->ReadLine();
            strcpy( option->m_currentString, in->GetRestOfLine() );
        }
    }

    delete in;


    ResetOptions();

#ifdef TESTBED
    GetOption("MaxTeams")->m_default = 2;
    GetOption("MaxTeams")->m_currentValue = 2;
    GetOption("MaxGameRealTime")->m_default = 15;
    GetOption("MaxGameRealTime")->m_currentValue = 15;
#endif


    m_score.Initialise(MAX_TEAMS);
    m_nukeCount.Initialise(MAX_TEAMS);
    m_totalNukes.Initialise(MAX_TEAMS);

    for( int t = 0; t < MAX_TEAMS; ++t )
    {
        m_score[t] = 0;
        m_nukeCount[t] = 0;
        m_totalNukes[t] = 0;
    }
}

Tutorial::Tutorial( int _startChapter )
:   m_currentChapter(-1),
    m_nextChapter(-1),
    m_nextChapterTimer(0.0f),
    m_objectHighlight(-1),    
    m_miscTimer(-1.0f),
    m_worldInitialised(false),
    m_startLevel(_startChapter)
{
    m_levelName[0] = '\x0';
    SetCurrentLevel(1);
    
    //
    // Parse the tutorial data file

    TextReader *reader = g_fileSystem->GetTextReader( "data/tutorial.txt" );
    AppAssert( reader && reader->IsOpen() );
    
    while( reader->ReadLine() )
    {
        if( !reader->TokenAvailable() ) continue;
        char *chapterHeading = reader->GetNextToken();
        AppAssert( stricmp( chapterHeading, "CHAPTER" ) == 0 );
        
        TutorialChapter *chapter = new TutorialChapter();
        m_chapters.PutData( chapter );

        chapter->m_name = strdup( reader->GetNextToken() );
        char temp[256];
        sprintf( temp, "tutorial_%s", chapter->m_name );
        chapter->m_message = strdup( temp );
        sprintf( temp, "tutorial_%s_obj", chapter->m_name );
        chapter->m_objective = strdup( temp );


        while( reader->ReadLine() )
        {
            if( !reader->TokenAvailable() ) continue;
            char *field = reader->GetNextToken();
            if( stricmp( field, "END" ) == 0 )      break;

            char *value = reader->GetRestOfLine();     
            if( value ) value[ strlen(value) - 1 ] = '\x0';
        
            if( stricmp( field, "MESSAGE" ) == 0 )              chapter->m_message = strdup(value);
            if( stricmp( field, "OBJECTIVE" ) == 0 )            chapter->m_objective = strdup(value);
            if( stricmp( field, "WINDOWHIGHLIGHT" ) == 0 )      chapter->m_windowHighlight = strdup(value);
            if( stricmp( field, "BUTTONHIGHLIGHT" ) == 0 )      chapter->m_buttonHighlight = strdup(value);
            
            if( stricmp( field, "NEXTCLICKABLE" ) == 0 )        
            {
                chapter->m_nextClickable = true;
                chapter->m_objective = strdup( "tutorial_clicknext" );
            }

            if( stricmp( field, "RESTARTCLICKABLE" ) == 0 )
            {
                chapter->m_restartClickable = true;
                chapter->m_objective = strdup("tutorial_restart_mission");
            }
        }
    }
}