Beispiel #1
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] );
}
Beispiel #2
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);
}
Beispiel #3
0
inline void WatchEntityEX::Archive(Archiver& arc) {
	Behavior::Archive(arc);

	// Archive Parameters
	arc.ArchiveString(&_stance);
	arc.ArchiveString(&_shuffleAnim);
	arc.ArchiveString(&_torsoAnim);
	arc.ArchiveSafePointer(&_ent);

	// Archive Components	
	arc.ArchiveObject(&_rotateToEntity);

	// Archive Member Vars      
	arc.ArchiveUnsigned(&_state);
	arc.ArchiveFloat(&_time);
	arc.ArchiveFloat(&_turnspeed);

}
Beispiel #4
0
inline void Work::Archive(Archiver& arc) {
	Behavior::Archive(arc);

	// Archive Parameters
	arc.ArchiveString(&_gotoWorkAnimName);
	arc.ArchiveFloat(&_maxDistance);

	// Archive Components
	arc.ArchiveObject(&_gotoHelperNode);


	// Archive Member Vars
	arc.ArchiveSafePointer(&_node);
	arc.ArchiveUnsigned(&_state);
	arc.ArchiveBool(&_animDone);
	arc.ArchiveFloat(&_endTime);
	arc.ArchiveObjectPointer((Class**)&_self);
}
inline void MoveRandomDirection::Archive(Archiver& arc) {
	Behavior::Archive(arc);

	// Archive Parameters
	arc.ArchiveString(&anim);

	// Archive Components
	arc.ArchiveObject(&_chase);

	// Archive Member Vars
	arc.ArchiveVector(&_destination);
	arc.ArchiveUnsigned(&_mode);
	arc.ArchiveFloat(&_dist);
	arc.ArchiveFloat(&_minDistance);
	arc.ArchiveFloat(&_nextChangeTime);
	arc.ArchiveBool(&_foundGoodDestination);
	arc.ArchiveBool(&_forever);
	arc.ArchiveBool(&_faceEnemy);
	arc.ArchiveString(&_torsoAnim);
}
Beispiel #6
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] );
    }
}
Beispiel #7
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 );
}