Example #1
0
//
// Name:        DoArchive
// Parameters:  Archiver &arc
//              Actor *actor
// Description: Sets the Actor pointer during archiving
//
void PackageManager::DoArchive( Archiver &arc , Actor *actor )
{
	int i;
	BehaviorPackageEntry_t *pEntry;
	BehaviorPackageType_t  *package;
	int numPackages;
	str packageName;

	if ( actor )
		act = actor;
	else 
		gi.Error( ERR_FATAL, "PackageManager::DoArchive -- actor is NULL" );

	if ( arc.Loading() )
	{
		arc.ArchiveInteger( &numPackages );

		for ( i = 1 ; i <= numPackages ; i++ )
		{
			arc.ArchiveString( &packageName );

			RegisterPackage( packageName );

			// The package we just added should always be the last one

			pEntry = &_BehaviorPackages.ObjectAt( _BehaviorPackages.NumObjects() );

			arc.ArchiveFloat( &pEntry->currentScore );
			arc.ArchiveFloat( &pEntry->lastScore );
			arc.ArchiveFloat( &pEntry->lastTimeExecuted );
			arc.ArchiveFloat( &pEntry->priority );
		}

	}
	else
	{
		numPackages = _BehaviorPackages.NumObjects();
		arc.ArchiveInteger( &numPackages );

		for ( i = 1 ; i <= _BehaviorPackages.NumObjects() ; i++ )
		{
			pEntry = &_BehaviorPackages.ObjectAt( i );

			package = PackageList.ObjectAt( pEntry->packageIndex );

			arc.ArchiveString( &package->packageName );

			arc.ArchiveFloat( &pEntry->currentScore );
			arc.ArchiveFloat( &pEntry->lastScore );
			arc.ArchiveFloat( &pEntry->lastTimeExecuted );
			arc.ArchiveFloat( &pEntry->priority );
		}
	}

	arc.ArchiveInteger( &_currentFVarIndex );
	arc.ArchiveFloat( &_currentFVarLastExecuteTime );
	arc.ArchiveInteger( &_currentPackageIndex );
}
Example #2
0
inline void def_t::Archive( Archiver &arc )
{
    Class::Archive( arc );

    arc.ArchiveObjectPointer( ( Class ** )&type );
    arc.ArchiveString( &name );
//	arc.ArchiveObjectPointer( ( Class ** )&next );
    arc.ArchiveInteger( &ofs );
    arc.ArchiveInteger( &localofs );
    arc.ArchiveObjectPointer( ( Class ** )&scope );
    arc.ArchiveInteger( &initialized );
    arc.ArchiveBool( &caseSensitive );

    arc.ArchiveBool( &_onDefList );
    //arc.ArchiveObjectPointer( ( Class ** )&type );
}
//
// Name:        Archive()
// Parameters:  Archiver &arc -- The archiver object
// Description: Archives the class
//
void SensoryPerception::Archive ( Archiver &arc )
{	
	arc.ArchiveInteger ( &_stimuli                   );
	arc.ArchiveInteger ( &_permanent_stimuli         );
	arc.ArchiveVector  ( &_noise_position            );
	arc.ArchiveInteger ( &_last_soundType            );
	arc.ArchiveFloat   ( &_noise_time                );
	arc.ArchiveFloat   ( &_fov                       );
	arc.ArchiveFloat   ( &_fovdot                    );
	arc.ArchiveFloat   ( &_vision_distance           );
	arc.ArchiveFloat   ( &_nextSenseTime	          );
	
	arc.ArchiveInteger( &_lineOfSight.entNum );
	arc.ArchiveFloat( &_lineOfSight.time );
	arc.ArchiveBoolean( &_lineOfSight.inLineOfSight );
}
Example #4
0
inline void PuzzleObject::Archive( Archiver &arc )
{
	Entity::Archive( arc );

	arc.ArchiveString( &_itemToUse				);
	arc.ArchiveString( &_itemUsedThread			);
	arc.ArchiveString( &_failedThread			);
	arc.ArchiveString( &_solvedThread			);
	arc.ArchiveString( &_canceledThread			);
	ArchiveEnum( _puzzleState, PuzzleState	);
	ArchiveEnum( _saveState, PuzzleState );

	arc.ArchiveFloat( &_openDistance );

	arc.ArchiveBool( &_timed );
	arc.ArchiveFloat( &_timeToUse );
	arc.ArchiveFloat( &_lastTimeUsed );
	arc.ArchiveFloat( &_usedTime );
	arc.ArchiveBool( &_hudOn );

	arc.ArchiveFloat( &_nextNeedToUseTime );

	arc.ArchiveString( &_hudName );
	
	arc.ArchiveInteger( &_minSkill );
}
Example #5
0
inline void type_t::Archive( Archiver &arc )
{
    int i;

    Class::Archive( arc );

    ArchiveEnum( type, etype_t );

    if ( arc.Loading() )
    {
        bool onList;

        arc.ArchiveBool( &onList );

        if ( !onList )
        {
            def = new def_t;

            arc.ArchiveObject( ( Class * )def );
        }
        else
        {
            arc.ArchiveObjectPointer( ( Class ** )&def );
        }

    }
    else
    {
        arc.ArchiveBool( &def->_onDefList );

        if ( !def->_onDefList )
        {
            arc.ArchiveObject( ( Class * )def );
        }
        else
        {
            arc.ArchiveObjectPointer( ( Class ** )&def );
        }
    }

    /* if ( arc.Loading() )
    	def = new def_t;

    arc.ArchiveObject( ( Class * )def ); */

    arc.ArchiveObjectPointer( ( Class ** )&def );

    arc.ArchiveObjectPointer( ( Class ** )&aux_type );

    arc.ArchiveInteger( &num_parms );
    arc.ArchiveInteger( &min_parms );

    for ( i = 0; i < num_parms; i++ )
        arc.ArchiveObjectPointer( ( Class ** )&parm_types[i] );
}
Example #6
0
inline void dfunction_t::Archive( Archiver &arc )
{
    Class::Archive( arc );

    arc.ArchiveInteger( &eventnum );
    arc.ArchiveInteger( &first_statement );
    arc.ArchiveInteger( &parm_start );
    arc.ArchiveInteger( &parm_total );
    arc.ArchiveInteger( &locals );

    arc.ArchiveInteger( &profile );

    arc.ArchiveString( &s_name );
    arc.ArchiveString( &s_file );

    arc.ArchiveInteger( &numparms );
    arc.ArchiveInteger( &minparms );

    if ( arc.Loading() )
    {
        memset( &parm_size, 0, sizeof( parm_size[0] ) * MAX_PARMS );
        memset( &parm_type, 0, sizeof( parm_type[0] ) * MAX_PARMS );
    }

    arc.ArchiveRaw( parm_size, sizeof( parm_size[0] ) * numparms );
    arc.ArchiveRaw( parm_type, sizeof( parm_type[0] ) * numparms );
}
Example #7
0
inline void Talk::Archive(Archiver& arc) {
    Behavior::Archive(arc);

    arc.ArchiveObject(&turnto);
    arc.ArchiveSafePointer(&ent_listening);
    arc.ArchiveSafePointer(&last_headwatch_target);
    arc.ArchiveFloat(&original_yaw);
    arc.ArchiveFloat(&yaw);
    arc.ArchiveInteger(&mode);
    arc.ArchiveBoolean(&move_allowed);
    arc.ArchiveBool(&animDone);
    arc.ArchiveString(&oldAnimName);
}
Example #8
0
void Entity::Archive( Archiver &arc )
{
	SimpleEntity::Archive( arc );

	arc.ArchiveBoolean( &fShader );

	if( fShader )
	{
		arc.ArchiveString( &shader );

		if( arc.Loading() ) {
			customshader = cgi.R_RegisterShader( shader );
		}
	}

	arc.ArchiveBoolean( &canThink );

	arc.ArchiveFloat( &scale );
	arc.ArchiveInteger( &entnum );
	arc.ArchiveInteger( &renderFx );

	arc.ArchiveString( &model );
}
Example #9
0
inline void Program::Archive( Archiver &arc )
{
    int i, num;
    type_t *curtype, *newtype;
    def_t *curdef, *newdef;

    Class::Archive( arc );

    /* // Force all of the defs to have indexes

    forceDefSave = &def_void;
    arc.ArchiveObjectPointer( ( Class ** )&forceDefSave );
    forceDefSave = &def_string;
    arc.ArchiveObjectPointer( ( Class ** )&forceDefSave );
    forceDefSave = &def_float;
    arc.ArchiveObjectPointer( ( Class ** )&forceDefSave );
    forceDefSave = &def_vector;
    arc.ArchiveObjectPointer( ( Class ** )&forceDefSave );
    forceDefSave = &def_entity;
    arc.ArchiveObjectPointer( ( Class ** )&forceDefSave );
    forceDefSave = &def_function;
    arc.ArchiveObjectPointer( ( Class ** )&forceDefSave );

    // Force all of the types to have indexes

    forceTypeSave = &type_void;
    arc.ArchiveObjectPointer( ( Class ** )&forceTypeSave );
    forceTypeSave = &type_string;
    arc.ArchiveObjectPointer( ( Class ** )&forceTypeSave );
    forceTypeSave = &type_float;
    arc.ArchiveObjectPointer( ( Class ** )&forceTypeSave );
    forceTypeSave = &type_vector;
    arc.ArchiveObjectPointer( ( Class ** )&forceTypeSave );
    forceTypeSave = &type_entity;
    arc.ArchiveObjectPointer( ( Class ** )&forceTypeSave );
    forceTypeSave = &type_function;
    arc.ArchiveObjectPointer( ( Class ** )&forceTypeSave ); */

    // NOTE: must archive global data for pointer fixups
    arc.ArchiveObject( &def_void );
    arc.ArchiveObject( &def_string );
    arc.ArchiveObject( &def_float );
    arc.ArchiveObject( &def_vector );
    arc.ArchiveObject( &def_entity );
    arc.ArchiveObject( &def_function );

    arc.ArchiveObject( &def_ret );
    arc.ArchiveObject( &junkdef );

    arc.ArchiveObject( &type_void );
    arc.ArchiveObject( &type_string );
    arc.ArchiveObject( &type_float );
    arc.ArchiveObject( &type_vector );
    arc.ArchiveObject( &type_entity );
    arc.ArchiveObject( &type_function );

    arc.ArchiveInteger( &numpr_globals );

    if ( arc.Loading() )
    {
        memset( pr_globals, 0, sizeof( pr_globals[0] ) * MAX_REGS );
    }

    arc.ArchiveRaw( pr_globals, sizeof( pr_globals[0] ) * numpr_globals );

    arc.ArchiveInteger( &locals_start );
    arc.ArchiveInteger( &locals_end );

    for ( i = 0; i < MAX_STRINGS; i++ )
    {
        arc.ArchiveBool( &strings[i].inuse );

        if ( strings[i].inuse )
        {
            arc.ArchiveString( &strings[i].s );
        }
        else
        {
            strings[i].s = "";
        }
    }

    arc.ArchiveInteger( &numstatements );
    arc.ArchiveRaw( statements, sizeof( statements[0] ) * numstatements );

    arc.ArchiveInteger( &numfunctions );
    for ( i = 0; i < numfunctions; i++ )
        arc.ArchiveObject( ( Class * )&functions[i] );

    // archive types
    if ( arc.Saving() )
    {
        for ( curtype = types, num = 0; curtype; curtype = curtype->next )
        {
            num++;
        }

        // Don't count type_function

        num--;
    }

    arc.ArchiveInteger( &num );

    if ( arc.Saving() )
    {
        for ( curtype = types; curtype; curtype = curtype->next )
        {
            // Skip type_function (we archive it seperately above)

            if ( curtype == &type_function )
                continue;

            arc.ArchiveObject( ( Class * )curtype );
        }
    }
    else
    {
        curtype = types;

        for ( i = 0; i < num; i++ )
        {
            newtype = new type_t;
            arc.ArchiveObject( ( Class * )newtype );
            newtype->next = NULL;

            curtype->next = newtype;
            curtype = newtype;
        }
    }

    // archive defs
    if ( arc.Saving() ) {
        for ( curdef = def_head.next, num = 0; curdef; curdef = curdef->next )
            num++;
    }

    arc.ArchiveInteger( &num );

    if ( arc.Saving() ) {
        for ( curdef = def_head.next; curdef; curdef = curdef->next )
            arc.ArchiveObject( ( Class * )curdef );
    }
    else {
        def_tail = &def_head;
        curdef = def_tail;

        for ( i = 0; i < num; i++ ) {
            newdef = new def_t;
            arc.ArchiveObject( ( Class * )newdef );
            newdef->next = NULL;

            curdef->next = newdef;
            curdef = newdef;
        }
    }

    arc.ArchiveInteger( &pr_error_count );

    filenames.Archive( arc );
    arc.ArchiveString( &s_file );

    if ( arc.Loading() )
    {
        memset( pr_global_defs, 0, sizeof( pr_global_defs ) );
    }

    for ( i = 0; i < numpr_globals; i++ )
    {
        arc.ArchiveObjectPointer( ( Class ** )&pr_global_defs[i] );
    }
}
Example #10
0
void Personality::Archive( Archiver &arc )
{
	int i;
	int j;
	int num;
	str packageName;
	BehaviorPackageType_t  *package;
	PackageTendency_t      *tendency;
	PackageTendency_t      tempTendency;
	
	Tendency_t             tempGeneralTendency;
	Tendency_t             *generalTendency;
	
	tempTendency.packageIndex = 0;
	tempTendency.tendency = 0.0f;
	tempTendency.lastTendencyCheck = 0.0f;
	
	arc.ArchiveFloat( &_aggressiveness );
	arc.ArchiveFloat( &_talkiness );
	
	arc.ArchiveFloat( &_anger );
	arc.ArchiveFloat( &_fear );
	
	if ( arc.Saving() )
	{
		num = _PackageTendencies.NumObjects();
		
		arc.ArchiveInteger( &num );
		
		for ( i = 1 ; i <= num ; i++ )
		{
			tendency = &_PackageTendencies.ObjectAt( i );
			
			package = PackageList.ObjectAt( tendency->packageIndex );
			
			arc.ArchiveString( &package->packageName );
			arc.ArchiveFloat( &tendency->tendency );
			arc.ArchiveFloat( &tendency->lastTendencyCheck );
			
		}
	}
	else
	{
		arc.ArchiveInteger( &num );
		
		_PackageTendencies.ClearObjectList();
		_PackageTendencies.Resize( num );
		
		for ( i = 1 ; i <= num ; i++ )
		{
			_PackageTendencies.AddObject( tempTendency );
			
			tendency = &_PackageTendencies.ObjectAt( i );
			
			arc.ArchiveString( &packageName );
			
			// Find index
			
			tendency->packageIndex = -1;
			
			for ( j = 1 ; j <= PackageList.NumObjects() ; j++ )
			{
				package = PackageList.ObjectAt( j );
				
				if ( stricmp( packageName.c_str() , package->packageName.c_str() ) == 0 )
				{
					tendency->packageIndex = j;
					break;
				}
			}
			
			assert( tendency->packageIndex != -1 );
			
			arc.ArchiveFloat( &tendency->tendency );
			arc.ArchiveFloat( &tendency->lastTendencyCheck );
		}
	}
	
	
	if ( arc.Saving() )
	{
		num = _Tendencies.NumObjects();
		
		arc.ArchiveInteger( &num );
		
		for ( i = 1 ; i <= num ; i++ )
		{
			generalTendency = &_Tendencies.ObjectAt( i );		
			
			arc.ArchiveString( &generalTendency->tendencyName  );
			arc.ArchiveFloat( &generalTendency->tendencyValue  );	
			
		}
	}
	else
	{
		arc.ArchiveInteger( &num );
		
		_Tendencies.ClearObjectList();
		_Tendencies.Resize( num );
		
		for ( i = 1 ; i <= num ; i++ )
		{
			_Tendencies.AddObject( tempGeneralTendency );
			
			generalTendency = &_Tendencies.ObjectAt( i );
			
			arc.ArchiveString( &generalTendency->tendencyName  );
			arc.ArchiveFloat( &generalTendency->tendencyValue  );
		}
	}
}
Example #11
0
void World::Archive( Archiver &arc )
{
	int i;
	int num;
	TargetList *tempTargetList;

	Entity::Archive( arc );

	if ( arc.Loading() )
	{
		FreeTargetList();
	}

	if ( arc.Saving() )
		num = targetList.NumObjects();

	arc.ArchiveInteger( &num );

	for ( i = 1; i <= num; i++ ) 
	{
		if ( arc.Saving() )
		{
			tempTargetList = targetList.ObjectAt( i );
		}
		else 
		{
			tempTargetList = new TargetList;
			targetList.AddObject( tempTargetList );
		}

		arc.ArchiveObject( ( Class * )tempTargetList );
	}

	_brokenThings.Archive( arc );

	_availableViewModes.Archive( arc );

	arc.ArchiveBoolean( &world_dying );

	arc.ArchiveString( &skipthread );
	arc.ArchiveFloat( &farplane_distance );
	arc.ArchiveVector( &farplane_color );
	arc.ArchiveBoolean( &farplane_cull );
	arc.ArchiveBoolean( &farplane_fog );
	arc.ArchiveBoolean( &terrain_global );
	arc.ArchiveFloat( &terrain_global_min );
	arc.ArchiveFloat( &entity_fade_dist );

	for( i = 0 ; i < MAX_LIGHTING_GROUPS ; i++ )
		dynamic_lights[ i ].Archive( arc );

	wind.Archive( arc );
	weather.Archive( arc );

	arc.ArchiveFloat( &time_scale );

	arc.ArchiveFloat( &sky_alpha );
	arc.ArchiveBoolean( &sky_portal );

	for ( i = 0 ; i < WORLD_PHYSICS_TOTAL_NUMBER ; i++ )
	{
		arc.ArchiveFloat( &_physicsInfo[ i ] );
	}

	arc.ArchiveBool( &_canShakeCamera );

	if ( arc.Loading() )
	{
		UpdateConfigStrings();
		UpdateFog();
		UpdateTerrain();
		UpdateSky();
		UpdateDynamicLights();
		UpdateWindDirection();
		UpdateWindIntensity();
		UpdateWeather();
		UpdateTimeScale();
	}

	// Archive groupcoordinator (not part of world but this is a good place)

	if ( arc.Loading() )
	{
		if ( groupcoordinator )
			delete groupcoordinator;

		groupcoordinator = new GroupCoordinator;
	}

	groupcoordinator->Archive( arc );
}
Example #12
0
void Level::Archive( Archiver &arc )
{
	int num;
	int i;

	Class::Archive( arc );

	if ( arc.Saving() )
	{
		SafePtr<Earthquake> ent;

		num = _earthquakes.NumObjects();
		arc.ArchiveInteger( &num );

		for ( i = 1 ; i <= num ; i++ )
		{
			ent = _earthquakes.ObjectAt( i );		
			arc.ArchiveSafePointer( &ent );		
		}
	}
	else
	{
		SafePtr<Earthquake> ent;
		SafePtr<Earthquake> *entityPointer;

		arc.ArchiveInteger( &num );

		_earthquakes.ClearObjectList();
		_earthquakes.Resize( num );

		for ( i = 1 ; i <= num ; i++ )
		{		
			_earthquakes.AddObject( ent );

			entityPointer = &_earthquakes.ObjectAt( i );

			arc.ArchiveSafePointer( entityPointer );
		}
	}

	arc.ArchiveInteger( &_totalEnemiesSpawned );

	// Don't archive these

	//const char     *current_map;
	//const char     *current_entities;

	//int			   spawn_entnum;
	arc.ArchiveInteger( &currentInstanceNumber );
    //int            spawnflags;

	arc.ArchiveInteger( &framenum );
	arc.ArchiveInteger( &inttime );
	arc.ArchiveFloat( &time );
	arc.ArchiveFloat( &timeInLevel );
	arc.ArchiveFloat( &frametime );
	arc.ArchiveFloat( &fixedframetime );
	arc.ArchiveInteger( &startTime );

	arc.ArchiveString( &level_name );
	arc.ArchiveString( &mapname );
	arc.ArchiveString( &spawnpoint );
	arc.ArchiveString( &nextmap );

	arc.ArchiveBoolean( &restart );
	arc.ArchiveBoolean( &started );

	arc.ArchiveBoolean( &playerfrozen );

	arc.ArchiveFloat( &intermissiontime );
	arc.ArchiveInteger( &exitintermission );
	arc.ArchiveFloat( &intermission_advancetime );
	arc.ArchiveBool( &_showIntermission );
	arc.ArchiveBool( &_saveOrientation );

	// Don't archive
	//gentity_s	   *next_edict;

	arc.ArchiveInteger( &total_secrets );
	arc.ArchiveInteger( &found_secrets );
	arc.ArchiveInteger( &total_specialItems );
	arc.ArchiveInteger( &found_specialItems );

	arc.ArchiveString( &game_script );

	// Don't archive
	//trace_t        impact_trace;

	arc.ArchiveBoolean( &cinematic );
	arc.ArchiveBoolean( &ai_on );

	arc.ArchiveBoolean( &mission_failed );
	arc.ArchiveBoolean( &died_already );

	arc.ArchiveBoolean( &near_exit );

	arc.ArchiveVector( &water_color );
	arc.ArchiveFloat( &water_alpha );

	arc.ArchiveVector( &slime_color );
	arc.ArchiveFloat( &slime_alpha );

	arc.ArchiveVector( &lava_color );
	arc.ArchiveFloat( &lava_alpha );

	arc.ArchiveString( &current_soundtrack );
	arc.ArchiveString( &saved_soundtrack );

	arc.ArchiveObjectPointer( ( Class ** )&consoleThread );

	arc.ArchiveVector( &m_fade_color );
	arc.ArchiveFloat( &m_fade_alpha );
	arc.ArchiveFloat( &m_fade_time );
	arc.ArchiveFloat( & m_fade_time_start );
	ArchiveEnum( m_fade_type, fadetype_t );
	ArchiveEnum( m_fade_style, fadestyle_t );

	arc.ArchiveFloat( &m_letterbox_fraction );
	arc.ArchiveFloat( &m_letterbox_time );
	arc.ArchiveFloat( &m_letterbox_time_start );
	ArchiveEnum( m_letterbox_dir, letterboxdir_t );

	arc.ArchiveBool( &_cleanup );

	arc.ArchiveString( &_playerDeathThread );

	arc.ArchiveObjectPointer( ( Class ** )&hNodeController );

	// Don't archive, will already be setup from camera code
	// Container<Camera *>	automatic_cameras;

	arc.ArchiveVector( & m_intermission_origin );
	arc.ArchiveVector( & m_intermission_angle );

	if ( arc.Loading() )
	{
		str temp_soundtrack;

		// Change the sound track to the one just loaded

		temp_soundtrack = saved_soundtrack;
		ChangeSoundtrack( current_soundtrack.c_str() );
		saved_soundtrack = temp_soundtrack;

		// not archived since we can't save mid-frame
		next_edict = NULL;
		// not archived since we can't save mid-frame
		memset( &impact_trace, 0, sizeof( impact_trace ) );

		loadLevelStrings();
	}
	
}