Пример #1
0
void Squad::Store(CivArchive &archive)
{
	
	int i;								
	Agent * the_agent;					
	

	

	m_squad_strength.Serialize(archive);

	
	archive.PutSINT32(my_agents.count);

	
	for (i = my_agents.count - 1; i >= 0; i--)
	{
		
		the_agent = (Agent *)
			my_agents.Return_Data_By_Number( i );

		
        archive.PutUINT32(the_agent->GetID().GetVal());

        archive.PutSINT32(the_agent->GetType());


	} 

    archive.PutSINT32(my_goal_id); 
}
Пример #2
0
void GoalBombard::Serialize(AiMain *ai,CivArchive &archive)
{
    CHECKSERIALIZE

    ArmyGoal::Serialize(ai, archive);
	uint32 v;

    if (archive.IsStoring()) {
         archive << m_foreign_player;
         archive.PutSINT32(m_target_id.GetVal());
         archive.PutSINT32(m_target_type);
    } else {
        archive >> m_foreign_player;
        v = archive.GetSINT32();
        m_target_id = v;
        v = archive.GetSINT32();
        m_target_type = (AGENT_TYPE) v;
    }
}
Пример #3
0
void GoalSally::Serialize(AiMain *ai,CivArchive &archive)
{
    CHECKSERIALIZE

    ArmyGoal::Serialize(ai, archive); 
	uint32 v;

    if (archive.IsStoring()) { 
         archive << m_foreign_player; 
         archive.PutSINT32(m_target_id.GetVal()); 
    } else { 
        archive >> m_foreign_player; 
        v = archive.GetSINT32(); 
        m_target_id = BSetID(v);
    } 
}
Пример #4
0
void
TradeRouteData::Serialize(CivArchive &archive)
{
	if(archive.IsStoring()) {
		archive << m_id;
		archive << m_transportCost;
		archive << m_owner;
		archive.PutSINT32(m_sourceRouteType);
		archive << m_sourceResource;
		archive.Store((uint8 *)m_passesThrough, sizeof(m_passesThrough)) ;
		archive.PutSINT32(m_crossesWater) ;
		archive.PutSINT8(static_cast<sint8>(m_isActive));
		archive.PutUINT32(m_color);
		archive.PutUINT32(m_outline);
		archive.PutSINT32(m_selectedIndex);
		archive.PutSINT32(m_path_selection_state);
		archive.PutSINT32(m_valid);
		archive << m_payingFor;
		archive << m_gold_in_return;

		m_sourceCity.Serialize(archive);
		m_destinationCity.Serialize(archive);
		m_recip.Serialize(archive);
		m_path.Serialize(archive);
		m_wayPoints.Serialize(archive) ;
		m_selectedPath.Serialize(archive);
		m_selectedWayPoints.Serialize(archive);
		m_astarPath->Serialize(archive);

		m_setPath.Serialize(archive);
		m_setWayPoints.Serialize(archive);

		uint8 hasChild;
		hasChild = m_lesser != NULL;
		archive << hasChild;
		if (m_lesser) {
			((TradeRouteData *)(m_lesser))->Serialize(archive) ;
		}

		hasChild = m_greater != NULL;
		archive << hasChild;
		if (m_greater)
			((TradeRouteData *)(m_greater))->Serialize(archive) ;

	} else {
		archive >> m_id;
		archive >> m_transportCost;
		archive >> m_owner;
		m_sourceRouteType = (ROUTE_TYPE)(archive.GetSINT32()) ;
		archive >> m_sourceResource;
		archive.Load((uint8 *)m_passesThrough, sizeof(m_passesThrough)) ;
		m_crossesWater = (BOOL)(archive.GetSINT32()) ;
		m_isActive = (BOOL)(archive.GetSINT8());
		m_color = archive.GetUINT32();
		m_outline = archive.GetUINT32();
		m_selectedIndex = archive.GetSINT32();
		m_path_selection_state = archive.GetSINT32();
		m_valid = archive.GetSINT32();
		archive >> m_payingFor;
		archive >> m_gold_in_return;

		m_sourceCity.Serialize(archive);
		m_destinationCity.Serialize(archive);
		m_recip.Serialize(archive);
		m_path.Serialize(archive);
		m_wayPoints.Serialize(archive) ;
		m_selectedPath.Serialize(archive);
		m_selectedWayPoints.Serialize(archive);
		m_astarPath->Serialize(archive);
		m_setPath.Serialize(archive);
		m_setWayPoints.Serialize(archive);

		uint8 hasChild;
		archive >> hasChild;
		if (hasChild) {
			m_lesser = new TradeRouteData(archive);
		} else {
			m_lesser = NULL;
		}

		archive >> hasChild;
		if (hasChild)
			m_greater = new TradeRouteData(archive);
		else
			m_greater = NULL;
	}
}
Пример #5
0
void SlicSegment::Serialize(CivArchive &archive)
{
	sint32 l;
	if(archive.IsStoring()) {
		archive.StoreChunk((uint8 *)&m_type, ((uint8 *)&m_fromFile)+sizeof(m_fromFile));

		if(m_id) {
			l = strlen(m_id) + 1;
			archive << l;
			archive.Store((uint8*)m_id, l);
		} else {
			l = 1;
			archive << l;
			archive.Store((uint8*)"", l);
		}
		archive.Store((uint8*)m_code, m_codeSize);
		archive.Store((uint8*)m_trigger_symbols_indices, m_num_trigger_symbols * sizeof(sint32));
		archive.Store((uint8*)m_lastShown, k_MAX_PLAYERS * sizeof(sint32));
		if(m_uiComponent) {
			l = strlen(m_uiComponent) + 1;
			archive << l;
			archive.Store((uint8*)m_uiComponent, l);
		} else {
			l = 0;
			archive << l;
		}
		archive << m_num_parameters;
		sint32 i;
		for(i = 0; i < m_num_parameters; i++) {
			archive.PutSINT32(((SlicParameterSymbol *)m_parameter_symbols[i])->GetIndex());
		}
		if(!m_filename) {
			archive.PutSINT32(0);
		} else {
			archive.PutSINT32(strlen(m_filename));
			archive.Store((uint8*)m_filename, strlen(m_filename));
		}
	} else {
		archive.LoadChunk((uint8 *)&m_type, ((uint8 *)&m_fromFile)+sizeof(m_fromFile));

		archive >> l;
		m_id = (char *)malloc(l);
		archive.Load((uint8*)m_id, l);
		m_code = (uint8*)malloc(m_codeSize);
		archive.Load((uint8*)m_code, m_codeSize);

		if (m_num_trigger_symbols < 1) {
			m_trigger_symbols_indices = NULL;
			m_trigger_symbols = NULL;
		} else {
			m_trigger_symbols_indices = new sint32[m_num_trigger_symbols];
			archive.Load((uint8*)m_trigger_symbols_indices, m_num_trigger_symbols * sizeof(sint32));
		}

		archive.Load((uint8*)m_lastShown, k_MAX_PLAYERS * sizeof(sint32));

		archive >> l;
		if(l > 0) {
			m_uiComponent = (char *)malloc(l);
			archive.Load((uint8*)m_uiComponent, l);
		} else {
			m_uiComponent = NULL;
		}

		archive >> m_num_parameters;
		m_parameter_indices = (m_num_parameters > 0) ? new sint32[m_num_parameters] : NULL;
		sint32 i;
		for(i = 0; i < m_num_parameters; i++) {
			m_parameter_indices[i] = archive.GetSINT32();
		}
		l = archive.GetSINT32();
		if(l > 0) {
			m_filename = (char *)malloc(l + 1);
			archive.Load((uint8*)m_filename, l);
			m_filename[l] = 0;
		} else {
			m_filename = NULL;
		}

		if(m_type == SLIC_OBJECT_HANDLEEVENT) {
			g_gevManager->AddCallback(m_event, m_priority, this);
		}
		m_parameter_symbols = NULL;
	}
}
Пример #6
0
void ForeignAgent::Serialize(IC3CivArchive *archive)
{

    CivArchive *a = (CivArchive *) archive; 

    Agent::Serialize(*a); 

    if (a->IsStoring()) { 

        a->PutSINT32(m_player_index); 

        a->PutSINT32(m_top_unit_type); 
        (*a) << m_defense_strength; 
        (*a) << m_attack_strength; 
        (*a) << m_target_value; 
        a->PutSINT32(m_has_peeked); 
        
        (*a) << m_pos->x; 
        (*a) << m_pos->y; 
        (*a) << m_pos->z; 
        (*a) << m_unit_num; 

        (*a) << m_XYpos->x; 
        (*a) << m_XYpos->y; 
        (*a) << m_XYpos->z; 

        a->PutSINT32(m_has_enslave_goal); 
		a->PutSINT32(enslave_me_goal_ID);
		a->PutSINT32(m_bombardMeGoalID);
		a->PutSINT32(m_rustleMeGoalID);
		a->PutSINT32(m_expelMeGoalID);
		a->PutSINT32(m_sallyMeGoalID);

        a->PutSINT32(m_lastSeen);

    } else { 
        m_player_index = PLAYER_INDEX(a->GetSINT32()); 

        m_top_unit_type = a->GetSINT32(); 
        (*a) >> m_defense_strength; 
        (*a) >> m_attack_strength; 
        (*a) >> m_target_value; 
        m_has_peeked = a->GetSINT32(); 

        (*a) >> m_pos->x; 
        (*a) >> m_pos->y; 
        (*a) >> m_pos->z; 

        (*a) >> m_unit_num; 

        (*a) >> m_XYpos->x; 
        (*a) >> m_XYpos->y; 
        (*a) >> m_XYpos->z; 

        m_has_enslave_goal = a->GetSINT32(); 
		enslave_me_goal_ID = a->GetSINT32();
		m_bombardMeGoalID = a->GetSINT32();
		m_rustleMeGoalID = a->GetSINT32();
		m_expelMeGoalID = a->GetSINT32();
		m_sallyMeGoalID = a->GetSINT32();

        m_lastSeen = a->GetSINT32(); 
    }
}