void AchievementTracker::Serialize(CivArchive &archive)
{
if(archive.IsStoring()) {
} else {
if(g_saveFileVersion < 55) {
archive >> m_achievements;
}
}
void FilenameDB::Serialize(CivArchive &archive)
{
CHECKSERIALIZE;
if (archive.IsStoring()) {
archive<<m_size ;
archive.Store((uint8 *)m_map, sizeof(FilenameNode) * m_size) ;
} else {
archive>>m_size ;
if (m_map)
delete m_map ;
m_map = new FilenameNode[m_size];
archive.Load((uint8 *)m_map, sizeof(FilenameNode) * m_size) ;
}
}
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;
}
}
void TaxRate::Serialize(CivArchive &archive)
{
if (archive.IsStoring()) {
archive << m_science;
archive << m_science_before_anarchy;
} else {
archive >> m_science;
archive >> m_science_before_anarchy;
}
}
void CivilisationData::Serialize(CivArchive &archive)
{
CHECKSERIALIZE
uint8 hasChild;
if (archive.IsStoring()) {
GameObj::Serialize(archive);
archive.StoreChunk((uint8 *)&m_owner, ((uint8 *)&m_singular_name)+sizeof(m_singular_name));
hasChild = m_lesser != NULL;
archive << hasChild;
if(m_lesser) {
((CivilisationData*)(m_lesser))->Serialize(archive);
}
hasChild = m_greater != NULL;
archive << hasChild;
if(m_greater) {
((CivilisationData*)(m_greater))->Serialize(archive);
}
} else {
GameObj::Serialize(archive);
archive.LoadChunk((uint8 *)&m_owner, ((uint8 *)&m_singular_name)+sizeof(m_singular_name));
archive >> hasChild;
if(hasChild) {
m_lesser = new CivilisationData(archive);
} else {
m_lesser = NULL;
}
archive >> hasChild;
if(hasChild) {
m_greater = new CivilisationData(archive);
} else {
m_greater = NULL;
}
}
}
void Strengths::Serialize(CivArchive &archive)
{
sint32 i;
if(archive.IsStoring()) {
archive << m_owner;
} else {
archive >> m_owner;
}
for(i = STRENGTH_CAT_NONE + 1; i < STRENGTH_CAT_MAX; i++) {
m_strengthRecords[i].Serialize(archive);
}
}
void OzoneDatabase::Serialize(CivArchive &archive)
{
#define UVDB_MAGIC 0x52139876
if (archive.IsStoring()) {
archive.PerformMagic(UVDB_MAGIC) ;
archive.StoreArrayString(m_meridian_prob, k_NUM_MERIDIANS + 1);
archive.StoreArrayString(m_meridian_phase_bonus, k_NUM_MERIDIANS+1);
archive.StoreArray(m_dead_food, k_MAX_RESOURCES);
archive.StoreArray(m_dead_shield, k_MAX_RESOURCES);
archive.StoreArray(m_dead_trade, k_MAX_RESOURCES);
archive.StoreArray(m_dead_gold, k_MAX_RESOURCES);
}
else {
}
}
void ThroneDB::Serialize(CivArchive &archive)
{
CHECKSERIALIZE;
if (archive.IsStoring()) {
archive << m_nThroneTypes;
archive << m_nThroneLevels;
archive.Store((uint8 *)m_throneInfo, sizeof(ThroneInfo) * m_nThroneTypes * m_nThroneLevels) ;
} else {
archive >> m_nThroneTypes;
archive >> m_nThroneLevels;
if(m_throneInfo) delete m_throneInfo;
m_throneInfo = new ThroneInfo[(m_nThroneTypes * m_nThroneLevels)];
archive.Load((uint8 *)m_throneInfo, sizeof(ThroneInfo) * m_nThroneTypes * m_nThroneLevels) ;
}
}
void Exclusions::Serialize(CivArchive &archive)
{
if(archive.IsStoring()) {
archive << m_numUnits;
archive << m_numBuildings;
archive << m_numWonders;
archive.Store((uint8 *)m_units, m_numUnits * sizeof(sint32));
archive.Store((uint8 *)m_buildings, m_numBuildings * sizeof(sint32));
archive.Store((uint8 *)m_wonders, m_numWonders * sizeof(sint32));
} else {
archive >> m_numUnits;
archive >> m_numBuildings;
archive >> m_numWonders;
m_units = new sint32[m_numUnits];
m_buildings = new sint32[m_numBuildings];
m_wonders = new sint32[m_numWonders];
archive.Load((uint8 *)m_units, m_numUnits * sizeof(sint32));
archive.Load((uint8 *)m_buildings, m_numBuildings * sizeof(sint32));
archive.Load((uint8 *)m_wonders, m_numWonders * sizeof(sint32));
if(m_numUnits != g_theUnitDB->NumRecords()) {
sint32 *newUnits = new sint32[g_theUnitDB->NumRecords()];
memset(newUnits, 0, g_theUnitDB->NumRecords() * sizeof(sint32));
memcpy(newUnits, m_units, std::min(m_numUnits, g_theUnitDB->NumRecords()) * sizeof(sint32));
delete [] m_units;
m_units = newUnits;
m_numUnits = g_theUnitDB->NumRecords();
}
if(m_numBuildings != g_theBuildingDB->NumRecords()) {
sint32 *newBuildings = new sint32[g_theBuildingDB->NumRecords()];
memset(newBuildings, 0, g_theBuildingDB->NumRecords() * sizeof(sint32));
memcpy(newBuildings, m_buildings, std::min(m_numBuildings, g_theBuildingDB->NumRecords()) * sizeof(sint32));
delete [] m_buildings;
m_buildings = newBuildings;
m_numBuildings = g_theBuildingDB->NumRecords();
}
if(m_numWonders != g_theWonderDB->NumRecords()) {
sint32 *newWonders = new sint32[g_theWonderDB->NumRecords()];
memset(newWonders, 0, g_theWonderDB->NumRecords() * sizeof(sint32));
memcpy(newWonders, m_wonders, std::min(m_numWonders, g_theWonderDB->NumRecords()) * sizeof(sint32));
delete [] m_wonders;
m_wonders = newWonders;
m_numWonders = g_theWonderDB->NumRecords();
}
}
}
void Pillaged_Node::Serialize(CivArchive &archive)
{
if (archive.IsStoring()) {
archive << m_pos.x;
archive << m_pos.y;
archive << m_pos.z;
archive << m_fix_me_by ;
archive << m_inst;
archive << m_attempt_count;
} else {
archive >> m_pos.x;
archive >> m_pos.y;
archive >> m_pos.z;
archive >> m_fix_me_by ;
archive >> m_inst;
archive >> m_attempt_count;
}
}
void GoalMapTarget::Serialize(AiMain *ai,CivArchive &archive)
{
CHECKSERIALIZE
ArmyGoal::Serialize(ai, archive);
sint32 index, count;
sint16 v;
MapPointData point;
if (archive.IsStoring())
{
v = (sint16) what_goal;
archive << v;
archive << m_moveType;
archive << (sint32) m_targets.Num();
for (index=0; index < m_targets.Num(); index++)
{
archive << m_targets[index].x;
archive << m_targets[index].y;
archive << m_targets[index].z;
}
}
else
{
archive >> v;
what_goal = (GOAL_TYPE) v;
archive >> m_moveType;
archive >> (sint32) count;
for (index=0; index < count; index++)
{
archive >> point.x;
archive >> point.y;
archive >> point.z;
m_targets.InsertFlat(point);
}
if (what_goal != GOAL_TYPE_WANDER)
ai->m_planner->the_strategic_map->
SetAreaGoal(point,what_goal,this);
else
ai->m_wanderGoalTargets->InsertFlat(this);
}
}
void Opportunity_Action_Repair_Installation::Serialize (CivArchive &archive)
{
Pillaged_Node *nth_node=NULL;
#ifdef _DEBUG
sint32 finite_count_oa_repair_serialize=0;
#endif
sint32 node_idx, num_stored_nodes;
if (archive.IsStoring()) {
archive << m_queue_len;
for (nth_node = m_head; nth_node; nth_node = nth_node->m_next) {
Assert(finite_count_oa_repair_serialize++ < m_queue_len);
nth_node->Serialize(archive);
}
} else {
archive >> num_stored_nodes;
if (num_stored_nodes < 1) {
m_queue_len = 0;
m_head = NULL;
m_tail = NULL;
} else {
for (node_idx=0; node_idx<num_stored_nodes; node_idx++) {
nth_node = new Pillaged_Node(archive);
Enqueue(nth_node);
}
m_dirty_tile_count = 0;
for (node_idx=0, nth_node = m_head; node_idx<num_stored_nodes; node_idx++, nth_node = nth_node->m_next) {
if (0 == nth_node->m_inst) {
m_dirty_tile_count++;
}
}
Assert(num_stored_nodes == m_queue_len);
}
}
}
void Squad::Serialize(CivArchive &archive)
{
CHECKSERIALIZE
Squad_Flat_Data::Serialize(archive);
if (archive.IsStoring())
{
Store(archive);
}
else
{
Load(archive);
}
}
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;
}
}
void DataCheck::BeginTurn(void)
{
CheckSum *check;
CivArchive *archive;
sint32 i, j;
clock_t start, finish;
for(i=CRC_TYPE_MIN; i<CRC_TYPE_MAX; i++)
for (j=0; j<CRC_ARRAY_MAX; j++)
m_old_crc[i][j] = m_crc[i][j];
memset(&m_time, 0, CRC_TYPE_MAX * sizeof(uint32));
start = clock();
archive = new CivArchive();
archive->SetStore();
check = new CheckSum() ;
// No idea what was serialized here
check->AddData(archive->GetStream(), archive->StreamLen());
check->Done(m_crc[CRC_TYPE_GLOBAL][CRC_ARRAY_0], m_crc[CRC_TYPE_GLOBAL][CRC_ARRAY_1], m_crc[CRC_TYPE_GLOBAL][CRC_ARRAY_2], m_crc[CRC_TYPE_GLOBAL][CRC_ARRAY_3]);
delete archive;
delete check;
finish = clock();
m_time[CRC_TYPE_GLOBAL] = finish - start;
// should be replaced by:
// CHECK_DB(???, CRC_TYPE_GLOBAL);
CHECK_DB(g_rand, CRC_TYPE_RAND);
start = clock();
archive = new CivArchive();
archive->SetStore();
check = new CheckSum();
// Fill in missing databases
g_theAdvanceDB->Serialize(*archive);
g_theAdvanceBranchDB->Serialize(*archive);
g_theAdvanceListDB->Serialize(*archive);
g_theAgeDB->Serialize(*archive);
g_theAgeCityStyleDB->Serialize(*archive);
g_theBuildListSequenceDB->Serialize(*archive);
g_theCitySizeDB->Serialize(*archive);
g_theCityStyleDB->Serialize(*archive);
g_theCivilisationDB->Serialize(*archive);
g_theConstDB->Serialize(*archive); // Old database
g_theDifficultyDB->Serialize(*archive);
g_theDiplomacyDB->Serialize(*archive);
g_theDiplomacyProposalDB->Serialize(*archive);
g_theDiplomacyThreatDB->Serialize(*archive);
g_theEndGameObjectDB->Serialize(*archive);
g_theGoalDB->Serialize(*archive);
g_theGovernmentDB->Serialize(*archive);
g_theIconDB->Serialize(*archive);
g_theImprovementListDB->Serialize(*archive);
g_theMapIconDB->Serialize(*archive);
g_theMapDB->Serialize(*archive);
g_theOrderDB->Serialize(*archive);
g_theUVDB->Serialize(*archive); // Old database
g_thePersonalityDB->Serialize(*archive);
g_thePollutionDB->Serialize(*archive);
g_thePopDB->Serialize(*archive);
g_theResourceDB->Serialize(*archive);
g_theRiskDB->Serialize(*archive);
g_theSoundDB->Serialize(*archive);
g_theSpecialAttackInfoDB->Serialize(*archive);
g_theSpecialEffectDB->Serialize(*archive);
g_theSpriteDB->Serialize(*archive);
g_theStrategyDB->Serialize(*archive);
g_theTerrainDB->Serialize(*archive);
g_theUnitDB->Serialize(*archive);
g_theUnitBuildListDB->Serialize(*archive);
g_theWonderDB->Serialize(*archive);
g_theWonderBuildListDB->Serialize(*archive);
check->AddData(archive->GetStream(), archive->StreamLen());
check->Done(m_crc[CRC_TYPE_DB][CRC_ARRAY_0], m_crc[CRC_TYPE_DB][CRC_ARRAY_1], m_crc[CRC_TYPE_DB][CRC_ARRAY_2], m_crc[CRC_TYPE_DB][CRC_ARRAY_3]);
delete archive;
delete check;
finish = clock();
m_time[CRC_TYPE_DB] = finish - start;
// Continue with single database check
start = clock();
archive = new CivArchive();
archive->SetStore();
check = new CheckSum();
// g_theProfileDB->Serialize(*archive);
check->AddData(archive->GetStream(), archive->StreamLen());
check->Done(m_crc[CRC_TYPE_PROFILE_DB][CRC_ARRAY_0], m_crc[CRC_TYPE_PROFILE_DB][CRC_ARRAY_1], m_crc[CRC_TYPE_PROFILE_DB][CRC_ARRAY_2], m_crc[CRC_TYPE_PROFILE_DB][CRC_ARRAY_3]);
delete archive;
delete check;
finish = clock();
m_time[CRC_TYPE_PROFILE_DB] = finish - start;
start = clock();
archive = new CivArchive();
archive->SetStore();
check = new CheckSum();
// g_theStringDB->Serialize(*archive);
check->AddData(archive->GetStream(), archive->StreamLen());
check->Done(m_crc[CRC_TYPE_STRING_DB][CRC_ARRAY_0], m_crc[CRC_TYPE_STRING_DB][CRC_ARRAY_1], m_crc[CRC_TYPE_STRING_DB][CRC_ARRAY_2], m_crc[CRC_TYPE_STRING_DB][CRC_ARRAY_3]);
delete archive ;
delete check ;
finish = clock() ;
m_time[CRC_TYPE_STRING_DB] = finish - start;
CHECK_DB(g_theAdvanceDB, CRC_TYPE_ADVANCE_DB);
CHECK_DB(g_theAdvanceBranchDB, CRC_TYPE_ADVANCE_BRANCH_DB);
CHECK_DB(g_theAdvanceListDB, CRC_TYPE_ADVANCE_LIST_DB);
CHECK_DB(g_theAgeDB, CRC_TYPE_AGE_DB);
CHECK_DB(g_theAgeCityStyleDB, CRC_TYPE_AGE_CITY_STYLE_DB);
CHECK_DB(g_theBuildListSequenceDB, CRC_TYPE_BUILD_LIST_SEQUENCE_DB);
CHECK_DB(g_theBuildingDB, CRC_TYPE_BUILDING_DB);
CHECK_DB(g_theBuildingBuildListDB, CRC_TYPE_BUILDING_BUILD_LIST_DB);
CHECK_DB(g_theCitySizeDB, CRC_TYPE_CITY_SIZE_DB);
CHECK_DB(g_theCityStyleDB, CRC_TYPE_CITY_STYLE_DB);
CHECK_DB(g_theCivilisationDB, CRC_TYPE_CIVILISATION_DB);
CHECK_DB(g_theConstDB, CRC_TYPE_CONST_DB);
CHECK_DB(g_theDifficultyDB, CRC_TYPE_DIFFICULTY_DB);
CHECK_DB(g_theDiplomacyDB, CRC_TYPE_DIPLOMACY_DB);
CHECK_DB(g_theDiplomacyProposalDB, CRC_TYPE_DIPLOMACY_PROPOSAL_DB);
CHECK_DB(g_theDiplomacyThreatDB, CRC_TYPE_DIPLOMACY_THREAT_DB);
CHECK_DB(g_theEndGameObjectDB, CRC_TYPE_END_GAME_OBJECT_DB);
CHECK_DB(g_theFeatDB, CRC_TYPE_FEAT_DB);
CHECK_DB(g_theGlobalWarmingDB, CRC_TYPE_GLOBAL_WARMING_DB);
CHECK_DB(g_theGoalDB, CRC_TYPE_GOAL_DB);
CHECK_DB(g_theGovernmentDB, CRC_TYPE_GOVERNMENT_DB);
CHECK_DB(g_theIconDB, CRC_TYPE_ICON_DB);
CHECK_DB(g_theImprovementListDB, CRC_TYPE_IMPROVEMENT_LIST_DB);
CHECK_DB(g_theMapDB, CRC_TYPE_MAP_DB);
CHECK_DB(g_theMapIconDB, CRC_TYPE_MAP_ICON_DB);
CHECK_DB(g_theOrderDB, CRC_TYPE_ORDER_DB);
CHECK_DB(g_theUVDB, CRC_TYPE_OZONE_DB);
CHECK_DB(g_thePersonalityDB, CRC_TYPE_PERSONALITY_DB);
CHECK_DB(g_thePollutionDB, CRC_TYPE_POLLUTION_DB);
CHECK_DB(g_thePopDB, CRC_TYPE_POPULATION_DB);
CHECK_DB(g_theResourceDB, CRC_TYPE_RESOURCE_DB);
CHECK_DB(g_theRiskDB, CRC_TYPE_RISK_DB);
CHECK_DB(g_theSoundDB, CRC_TYPE_SOUND_DB);
CHECK_DB(g_theSpecialAttackInfoDB, CRC_TYPE_SPECIAL_ATTACK_INFO_DB);
CHECK_DB(g_theSpecialEffectDB, CRC_TYPE_SPECIAL_EFFECT_DB);
CHECK_DB(g_theSpriteDB, CRC_TYPE_SPRITE_DB);
CHECK_DB(g_theStrategyDB, CRC_TYPE_STRATEGY_DB);
CHECK_DB(g_theTerrainDB, CRC_TYPE_TERRAIN_DB);
CHECK_DB(g_theUnitDB, CRC_TYPE_UNIT_DB);
CHECK_DB(g_theUnitBuildListDB, CRC_TYPE_UNIT_BUILD_LIST_DB);
CHECK_DB(g_theWonderDB, CRC_TYPE_WONDER_DB);
CHECK_DB(g_theWonderBuildListDB, CRC_TYPE_WONDER_BUILD_LIST_DB);
CHECK_DB(g_theAgreementPool, CRC_TYPE_AGREEMENTPOOL);
CHECK_DB(g_theCivilisationPool, CRC_TYPE_CIVILISATIONPOOL);
CHECK_DB(g_theDiplomaticRequestPool, CRC_TYPE_DIPLOMATICREQUESTPOOL);
CHECK_DB(g_theMessagePool, CRC_TYPE_MESSAGEPOOL);
CHECK_DB(g_theTerrainImprovementPool, CRC_TYPE_TERRAIN_IMPROVEMENT_POOL);
CHECK_DB(g_theTradePool, CRC_TYPE_TRADEPOOL);
CHECK_DB(g_theTradeOfferPool, CRC_TYPE_TRADEOFFERPOOL);
CHECK_DB(g_theUnitPool, CRC_TYPE_UNITPOOL);
CHECK_DB(g_thePollution, CRC_TYPE_POLLUTION);
CHECK_DB(g_selected_item, CRC_TYPE_SELECTED_ITEM);
CHECK_DB(g_theTopTen, CRC_TYPE_TOPTEN);
CHECK_DB(g_theWorld, CRC_TYPE_WORLD);
start = clock();
archive = new CivArchive();
archive->SetStore();
check = new CheckSum();
for (i=0; i<k_MAX_PLAYERS; i++) {
if(!g_player[i]) continue;
g_player[i]->Serialize(*archive);
}
check->AddData(archive->GetStream(), archive->StreamLen());
check->Done(m_crc[CRC_TYPE_PLAYER][CRC_ARRAY_0], m_crc[CRC_TYPE_PLAYER][CRC_ARRAY_1], m_crc[CRC_TYPE_PLAYER][CRC_ARRAY_2], m_crc[CRC_TYPE_PLAYER][CRC_ARRAY_3]);
delete archive;
delete check;
finish = clock();
m_time[CRC_TYPE_PLAYER] = finish - start ;
m_total_time = 0;
for(i = 0; i < CRC_ARRAY_MAX; ++i)
m_total_time += m_time[i];
}
//----------------------------------------------------------------------------
//
// Name : UnseenCell::Serialize
//
// Description: Serialization method
//
// Parameters : archive : The source/target archive
//
// Globals : -
//
// Returns : -
//
// Remark(s) : -
//
//----------------------------------------------------------------------------
void UnseenCell::Serialize(CivArchive &archive)
{
sint32 l;
if(archive.IsStoring()) {
m_point.Serialize(archive);
archive.StoreChunk((uint8 *)&m_env, ((uint8 *)&m_slaveBits)+sizeof(m_slaveBits));
{
// A dirty workaround in order not to change the save game format.
// UnseenInstallationInfo is now abused to store m_visibleCityOwner
// as visibility member. As both are of type uint32 it is not a
// problem. Its type is marked as -1. At least this doesn't interfere
// with anything else, as the installation data is just stored in
// this class but it isn't aceessed. Maybe a mistake or a left
// over from CTP1.
m_installations->AddTail(new UnseenInstallationInfo(-1, m_visibleCityOwner));
archive << m_installations->GetCount();
PointerList<UnseenInstallationInfo>::Walker walk(m_installations);
while(walk.IsValid()) {
archive.Store((uint8*)walk.GetObj(), sizeof(UnseenInstallationInfo));
walk.Next();
}
}
{
archive << m_improvements->GetCount();
PointerList<UnseenImprovementInfo>::Walker walk(m_improvements);
while(walk.IsValid()) {
archive.Store((uint8*)walk.GetObj(), sizeof(UnseenImprovementInfo));
walk.Next();
}
}
if (m_cityName)
{
l = strlen(m_cityName) + 1;
archive << l;
archive.Store((uint8*)m_cityName, (strlen(m_cityName) + 1) * sizeof(MBCHAR));
}
else
{
l = 0;
archive << l;
}
archive << (sint32)(m_actor != NULL);
if (m_actor) {
m_actor->Serialize(archive);
}
m_tileInfo->Serialize(archive);
}
else
{
m_point.Serialize(archive);
archive.LoadChunk((uint8 *)&m_env, ((uint8 *)&m_slaveBits)+sizeof(m_slaveBits));
if (m_installations)
{
m_installations->DeleteAll();
}
else
{
m_installations = new PointerList<UnseenInstallationInfo>;
}
archive >> l;
UnseenInstallationInfo* tmpUII;
bool vCityOwnerNotSet = true;
sint32 i;
for(i = 0; i < l; i++) {
tmpUII = new UnseenInstallationInfo(archive);
// Only store the additional UnseenInstallationInfo in the
// save file but not in the UnseenCell object itsself.
if(tmpUII->m_type >= 0){
m_installations->AddTail(tmpUII);
}
else{
m_visibleCityOwner = tmpUII->m_visibility;
vCityOwnerNotSet = false;
delete tmpUII;
}
}
// Backwards compartibility: If this UnseenCell didn't have an m_visibleCityOwner
if(vCityOwnerNotSet) m_visibleCityOwner = g_theWorld->GetCell(m_point)->GetCityOwner().m_id;
if (m_improvements)
{
m_improvements->DeleteAll();
}
else
{
m_improvements = new PointerList<UnseenImprovementInfo>;
}
archive >> l;
for(i = 0; i < l; i++) {
m_improvements->AddTail(new UnseenImprovementInfo(archive));
}
delete [] m_cityName;
archive >> l;
if (l > 0)
{
m_cityName = new MBCHAR[l];
archive.Load((uint8*)m_cityName, l * sizeof(MBCHAR));
}
else
{
m_cityName = NULL;
}
sint32 hasActor;
archive >> hasActor;
ReleaseActor(m_actor);
if (hasActor)
{
m_actor = new UnitActor(archive);
}
delete m_tileInfo;
m_tileInfo = new TileInfo(g_theWorld->GetTileInfo(m_point));
Assert(m_tileInfo);
m_tileInfo->Serialize(archive);
}
}
//----------------------------------------------------------------------------
//
// Name : UnseenInstallationInfo::UnseenInstallationInfo
//
// Description: Constructor
//
// Parameters : archive : The source archive
//
// Globals : -
//
// Returns : -
//
// Remark(s) : The constructor for loading
//
//----------------------------------------------------------------------------
UnseenInstallationInfo::UnseenInstallationInfo(CivArchive &archive)
{
archive.Load((uint8*)&m_type, sizeof(UnseenInstallationInfo));
}
//----------------------------------------------------------------------------
//
// Name : UnseenInstallationInfo::UnseenInstallationInfo
//
// Description: Constructor
//
// Parameters : archive : The source archive
//
// Globals : -
//
// Returns : -
//
// Remark(s) : The constructor for loading
//
//----------------------------------------------------------------------------
UnseenImprovementInfo::UnseenImprovementInfo(CivArchive &archive)
{
archive.Load((uint8*)&m_type, sizeof(UnseenImprovementInfo));
}
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();
}
}
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;
}
}
