Match Serialize functions to BETA10 (#1334)

* Begin refactor Serialize functions

* Match more Serialize functions

* Match `LegoVehicleBuildState::Serialize`

* Match `LegoGameState::Username::Serialize`

* Match `LegoGameState::ScoreItem::Serialize`

* Match `LegoGameState::History::Serialize`

* Var name

* Var name

* Revert "Var name"

This reverts commit 1c0cccfba7.

* Add other Serialize implementations

* Add remaining Serialize implementations

* Add Read for char*

* Improvements

LEGO1/lego/legoomni/src/actors/ambulance.cpp

@@ -646,33 +646,34 @@ AmbulanceMissionState::AmbulanceMissionState()
 }
 
 // FUNCTION: LEGO1 0x10037440
+// FUNCTION: BETA10 0x10024480
 MxResult AmbulanceMissionState::Serialize(LegoFile* p_file)
 {
 	LegoState::Serialize(p_file);
 
 	if (p_file->IsReadMode()) {
-		Read(p_file, &m_peScore);
-		Read(p_file, &m_maScore);
-		Read(p_file, &m_paScore);
-		Read(p_file, &m_niScore);
-		Read(p_file, &m_laScore);
-		Read(p_file, &m_peHighScore);
-		Read(p_file, &m_maHighScore);
-		Read(p_file, &m_paHighScore);
-		Read(p_file, &m_niHighScore);
-		Read(p_file, &m_laHighScore);
+		p_file->Read(m_peScore);
+		p_file->Read(m_maScore);
+		p_file->Read(m_paScore);
+		p_file->Read(m_niScore);
+		p_file->Read(m_laScore);
+		p_file->Read(m_peHighScore);
+		p_file->Read(m_maHighScore);
+		p_file->Read(m_paHighScore);
+		p_file->Read(m_niHighScore);
+		p_file->Read(m_laHighScore);
 	}
 	else if (p_file->IsWriteMode()) {
-		Write(p_file, m_peScore);
-		Write(p_file, m_maScore);
-		Write(p_file, m_paScore);
-		Write(p_file, m_niScore);
-		Write(p_file, m_laScore);
-		Write(p_file, m_peHighScore);
-		Write(p_file, m_maHighScore);
-		Write(p_file, m_paHighScore);
-		Write(p_file, m_niHighScore);
-		Write(p_file, m_laHighScore);
+		p_file->Write(m_peScore);
+		p_file->Write(m_maScore);
+		p_file->Write(m_paScore);
+		p_file->Write(m_niScore);
+		p_file->Write(m_laScore);
+		p_file->Write(m_peHighScore);
+		p_file->Write(m_maHighScore);
+		p_file->Write(m_paHighScore);
+		p_file->Write(m_niHighScore);
+		p_file->Write(m_laHighScore);
 	}
 
 	return SUCCESS;

LEGO1/lego/legoomni/src/actors/pizza.cpp

@@ -605,18 +605,25 @@ PizzaMissionState::PizzaMissionState()
 }
 
 // FUNCTION: LEGO1 0x100393c0
+// FUNCTION: BETA10 0x100eebf2
 MxResult PizzaMissionState::Serialize(LegoFile* p_file)
 {
 	LegoState::Serialize(p_file);
 
 	if (p_file->IsReadMode()) {
 		for (MxS16 i = 0; i < 5; i++) {
-			m_missions[i].ReadFromFile(p_file);
+			p_file->Read(m_missions[i].m_unk0x06);
+			p_file->Read(m_missions[i].m_unk0x14);
+			p_file->Read(m_missions[i].m_score);
+			p_file->Read(m_missions[i].m_hiScore);
 		}
 	}
 	else if (p_file->IsWriteMode()) {
 		for (MxS16 i = 0; i < 5; i++) {
-			m_missions[i].WriteToFile(p_file);
+			p_file->Write(m_missions[i].m_unk0x06);
+			p_file->Write(m_missions[i].m_unk0x14);
+			p_file->Write(m_missions[i].m_score);
+			p_file->Write(m_missions[i].m_hiScore);
 		}
 	}
 
@@ -633,6 +640,7 @@ PizzaMissionState::Mission* PizzaMissionState::GetMission(MxU8 p_actorId)
 		}
 	}
 
+	assert("No pizza mission for this character!" == NULL);
 	return NULL;
 }
 

LEGO1/lego/legoomni/src/actors/pizzeria.cpp

@@ -124,12 +124,12 @@ MxResult PizzeriaState::Serialize(LegoFile* p_file)
 
 	if (p_file->IsReadMode()) {
 		for (MxS16 i = 0; i < 5; i++) {
-			m_unk0x08[i].ReadFromFile(p_file);
+			p_file->Read(m_unk0x08[i].m_nextIndex);
 		}
 	}
 	else {
 		for (MxS16 i = 0; i < 5; i++) {
-			m_unk0x08[i].WriteToFile(p_file);
+			p_file->Write(m_unk0x08[i].m_nextIndex);
 		}
 	}
 

LEGO1/lego/legoomni/src/actors/radio.cpp

@@ -209,6 +209,7 @@ void Radio::CreateState()
 }
 
 // FUNCTION: LEGO1 0x1002ce10
+// FUNCTION: BETA10 0x100f20f6
 RadioState::RadioState()
 {
 	srand(Timer()->GetTime());
@@ -217,13 +218,13 @@ RadioState::RadioState()
 	m_unk0x2c = random % 3;
 
 	m_unk0x08[0] = Playlist((MxU32*) g_unk0x100f3218, sizeOfArray(g_unk0x100f3218), Playlist::e_loop);
-	m_unk0x08[0].SetNextIndex(rand() % sizeOfArray(g_unk0x100f3218));
+	m_unk0x08[0].m_nextIndex = (rand() % sizeOfArray(g_unk0x100f3218));
 
 	m_unk0x08[1] = Playlist((MxU32*) g_unk0x100f3230, sizeOfArray(g_unk0x100f3230), Playlist::e_loop);
-	m_unk0x08[1].SetNextIndex(rand() % sizeOfArray(g_unk0x100f3230));
+	m_unk0x08[1].m_nextIndex = (rand() % sizeOfArray(g_unk0x100f3230));
 
 	m_unk0x08[2] = Playlist((MxU32*) g_unk0x100f3268, sizeOfArray(g_unk0x100f3268), Playlist::e_loop);
-	m_unk0x08[2].SetNextIndex(rand() % sizeOfArray(g_unk0x100f3268));
+	m_unk0x08[2].m_nextIndex = (rand() % sizeOfArray(g_unk0x100f3268));
 
 	m_active = FALSE;
 }

LEGO1/lego/legoomni/src/actors/towtrack.cpp

@@ -609,33 +609,34 @@ TowTrackMissionState::TowTrackMissionState()
 }
 
 // FUNCTION: LEGO1 0x1004dde0
+// FUNCTION: BETA10 0x100f8720
 MxResult TowTrackMissionState::Serialize(LegoFile* p_file)
 {
 	LegoState::Serialize(p_file);
 
 	if (p_file->IsReadMode()) {
-		Read(p_file, &m_peScore);
-		Read(p_file, &m_maScore);
-		Read(p_file, &m_paScore);
-		Read(p_file, &m_niScore);
-		Read(p_file, &m_laScore);
-		Read(p_file, &m_peHighScore);
-		Read(p_file, &m_maHighScore);
-		Read(p_file, &m_paHighScore);
-		Read(p_file, &m_niHighScore);
-		Read(p_file, &m_laHighScore);
+		p_file->Read(m_peScore);
+		p_file->Read(m_maScore);
+		p_file->Read(m_paScore);
+		p_file->Read(m_niScore);
+		p_file->Read(m_laScore);
+		p_file->Read(m_peHighScore);
+		p_file->Read(m_maHighScore);
+		p_file->Read(m_paHighScore);
+		p_file->Read(m_niHighScore);
+		p_file->Read(m_laHighScore);
 	}
 	else if (p_file->IsWriteMode()) {
-		Write(p_file, m_peScore);
-		Write(p_file, m_maScore);
-		Write(p_file, m_paScore);
-		Write(p_file, m_niScore);
-		Write(p_file, m_laScore);
-		Write(p_file, m_peHighScore);
-		Write(p_file, m_maHighScore);
-		Write(p_file, m_paHighScore);
-		Write(p_file, m_niHighScore);
-		Write(p_file, m_laHighScore);
+		p_file->Write(m_peScore);
+		p_file->Write(m_maScore);
+		p_file->Write(m_paScore);
+		p_file->Write(m_niScore);
+		p_file->Write(m_laScore);
+		p_file->Write(m_peHighScore);
+		p_file->Write(m_maHighScore);
+		p_file->Write(m_paHighScore);
+		p_file->Write(m_niHighScore);
+		p_file->Write(m_laHighScore);
 	}
 
 	return SUCCESS;

LEGO1/lego/legoomni/src/build/legocarbuild.cpp

@@ -1704,21 +1704,26 @@ LegoVehicleBuildState::LegoVehicleBuildState(const char* p_classType)
 }
 
 // FUNCTION: LEGO1 0x10026120
+// FUNCTION: BETA10 0x1006eef0
 MxResult LegoVehicleBuildState::Serialize(LegoFile* p_file)
 {
 	LegoState::Serialize(p_file);
 
 	if (p_file->IsReadMode()) {
-		Read(p_file, &m_unk0x4c);
-		Read(p_file, &m_unk0x4d);
-		Read(p_file, &m_unk0x4e);
-		Read(p_file, &m_placedPartCount);
+		p_file->Read(m_unk0x4c);
+		p_file->Read(m_unk0x4d);
+		p_file->Read(m_unk0x4e);
+#ifndef BETA10
+		p_file->Read(m_placedPartCount);
+#endif
 	}
 	else {
-		Write(p_file, m_unk0x4c);
-		Write(p_file, m_unk0x4d);
-		Write(p_file, m_unk0x4e);
-		Write(p_file, m_placedPartCount);
+		p_file->Write(m_unk0x4c);
+		p_file->Write(m_unk0x4d);
+		p_file->Write(m_unk0x4e);
+#ifndef BETA10
+		p_file->Write(m_placedPartCount);
+#endif
 	}
 
 	return SUCCESS;

LEGO1/lego/legoomni/src/common/legoanimationmanager.cpp

@@ -2937,67 +2937,75 @@ void AnimState::InitFromAnims(MxU32 p_animsLength, AnimInfo* p_anims, MxU32 p_ex
 // FUNCTION: BETA10 0x10046621
 MxResult AnimState::Serialize(LegoFile* p_file)
 {
-	// These two are equivalent up to the order of some deallocation.
-	// Choose as needed to get 100 %.
-	// Option 1:
-	// LegoState::Serialize(p_file);
-	// Option 2:
-	if (p_file->IsWriteMode()) {
-		p_file->WriteString(ClassName());
-	}
+	MxResult result = LegoState::Serialize(p_file);
 
-	if (p_file->IsReadMode()) {
-		Read(p_file, &m_extraCharacterId);
+	if (result == SUCCESS) {
+		if (p_file->IsReadMode()) {
+			MxS32 i;
 
-		if (m_unk0x10) {
-			delete[] m_unk0x10;
-		}
+			p_file->Read(m_extraCharacterId);
 
-		Read(p_file, &m_unk0x0c);
-		if (m_unk0x0c != 0) {
+			if (m_unk0x10) {
+				delete[] m_unk0x10;
+			}
+
+			p_file->Read(m_unk0x0c);
+
+#ifndef BETA10
+			if (m_unk0x0c != 0) {
+				m_unk0x10 = new MxU16[m_unk0x0c];
+			}
+			else {
+				m_unk0x10 = NULL;
+			}
+#else
 			m_unk0x10 = new MxU16[m_unk0x0c];
-		}
-		else {
-			m_unk0x10 = NULL;
-		}
+#endif
 
-		for (MxS32 i = 0; i < m_unk0x0c; i++) {
-			Read(p_file, &m_unk0x10[i]);
-		}
+			for (i = 0; i < m_unk0x0c; i++) {
+				p_file->Read(m_unk0x10[i]);
+			}
 
-		// Note that here we read first and then free memory in contrast to above
-		Read(p_file, &m_locationsFlagsLength);
+			// Note that here we read first and then free memory in contrast to above
+			p_file->Read(m_locationsFlagsLength);
 
-		if (m_locationsFlags) {
-			delete[] m_locationsFlags;
-		}
+#ifndef BETA10
+			if (m_locationsFlags) {
+				delete[] m_locationsFlags;
+			}
 
-		if (m_locationsFlagsLength != 0) {
+			if (m_locationsFlagsLength != 0) {
+				m_locationsFlags = new MxBool[m_locationsFlagsLength];
+			}
+			else {
+				m_locationsFlags = NULL;
+			}
+#else
 			m_locationsFlags = new MxBool[m_locationsFlagsLength];
-		}
-		else {
-			m_locationsFlags = NULL;
-		}
+#endif
 
-		for (MxS32 j = 0; j < m_locationsFlagsLength; j++) {
-			Read(p_file, &m_locationsFlags[j]);
+			for (i = 0; i < m_locationsFlagsLength; i++) {
+				p_file->Read(m_locationsFlags[i]);
+			}
 		}
-	}
-	else if (p_file->IsWriteMode()) {
-		Write(p_file, m_extraCharacterId);
+		else if (p_file->IsWriteMode()) {
+			MxS32 i;
 
-		Write(p_file, m_unk0x0c);
-		for (MxS32 i = 0; i < m_unk0x0c; i++) {
-			Write(p_file, m_unk0x10[i]);
-		}
+			p_file->Write(m_extraCharacterId);
+			p_file->Write(m_unk0x0c);
 
-		Write(p_file, m_locationsFlagsLength);
-		for (MxS32 j = 0; j < m_locationsFlagsLength; j++) {
-			Write(p_file, m_locationsFlags[j]);
+			for (i = 0; i < m_unk0x0c; i++) {
+				p_file->Write(m_unk0x10[i]);
+			}
+
+			p_file->Write(m_locationsFlagsLength);
+			for (i = 0; i < m_locationsFlagsLength; i++) {
+				p_file->Write(m_locationsFlags[i]);
+			}
 		}
 	}
 
-	return SUCCESS;
+	return result;
 }
 
 // FUNCTION: LEGO1 0x100654f0

LEGO1/lego/legoomni/src/common/legogamestate.cpp

@@ -171,6 +171,7 @@ LegoGameState::~LegoGameState()
 }
 
 // FUNCTION: LEGO1 0x10039780
+// FUNCTION: BETA10 0x10083d43
 void LegoGameState::SetActor(MxU8 p_actorId)
 {
 	if (p_actorId) {
@@ -238,7 +239,7 @@ MxResult LegoGameState::Save(MxULong p_slot)
 	}
 
 	MxResult result = FAILURE;
-	LegoFile fileStorage;
+	LegoFile storage;
 	MxVariableTable* variableTable = VariableTable();
 	MxS16 count = 0;
 	MxU32 i;
@@ -248,32 +249,32 @@ MxResult LegoGameState::Save(MxULong p_slot)
 	MxString savePath;
 	GetFileSavePath(&savePath, p_slot);
 
-	if (fileStorage.Open(savePath.GetData(), LegoFile::c_write) == FAILURE) {
+	if (storage.Open(savePath.GetData(), LegoFile::c_write) == FAILURE) {
 		goto done;
 	}
 
-	Write(&fileStorage, 0x1000c);
-	Write(&fileStorage, m_unk0x24);
-	Write(&fileStorage, (MxU16) m_currentAct);
-	Write(&fileStorage, m_actorId);
+	storage.Write(0x1000c);
+	storage.Write(m_unk0x24);
+	storage.Write((MxU16) m_currentAct);
+	storage.Write(m_actorId);
 
 	for (i = 0; i < sizeOfArray(g_colorSaveData); i++) {
-		if (WriteVariable(&fileStorage, variableTable, g_colorSaveData[i].m_targetName) == FAILURE) {
+		if (WriteVariable(&storage, variableTable, g_colorSaveData[i].m_targetName) == FAILURE) {
 			goto done;
 		}
 	}
 
-	if (WriteVariable(&fileStorage, variableTable, "backgroundcolor") == FAILURE) {
+	if (WriteVariable(&storage, variableTable, "backgroundcolor") == FAILURE) {
 		goto done;
 	}
-	if (WriteVariable(&fileStorage, variableTable, "lightposition") == FAILURE) {
+	if (WriteVariable(&storage, variableTable, "lightposition") == FAILURE) {
 		goto done;
 	}
 
-	WriteEndOfVariables(&fileStorage);
-	CharacterManager()->Write(&fileStorage);
-	PlantManager()->Write(&fileStorage);
-	result = BuildingManager()->Write(&fileStorage);
+	WriteEndOfVariables(&storage);
+	CharacterManager()->Write(&storage);
+	PlantManager()->Write(&storage);
+	result = BuildingManager()->Write(&storage);
 
 	for (j = 0; j < m_stateCount; j++) {
 		if (m_stateArray[j]->IsSerializable()) {
@@ -281,16 +282,16 @@ MxResult LegoGameState::Save(MxULong p_slot)
 		}
 	}
 
-	Write(&fileStorage, count);
+	storage.Write(count);
 
 	for (j = 0; j < m_stateCount; j++) {
 		if (m_stateArray[j]->IsSerializable()) {
-			m_stateArray[j]->Serialize(&fileStorage);
+			m_stateArray[j]->Serialize(&storage);
 		}
 	}
 
 	area = m_unk0x42c;
-	Write(&fileStorage, (MxU16) area);
+	storage.Write((MxU16) area);
 	SerializeScoreHistory(2);
 	m_isDirty = FALSE;
 
@@ -322,42 +323,43 @@ MxResult LegoGameState::DeleteState()
 }
 
 // FUNCTION: LEGO1 0x10039c60
+// FUNCTION: BETA10 0x10084329
 MxResult LegoGameState::Load(MxULong p_slot)
 {
 	MxResult result = FAILURE;
-	LegoFile fileStorage;
+	LegoFile storage;
 	MxVariableTable* variableTable = VariableTable();
 
 	MxString savePath;
 	GetFileSavePath(&savePath, p_slot);
 
-	if (fileStorage.Open(savePath.GetData(), LegoFile::c_read) == FAILURE) {
+	if (storage.Open(savePath.GetData(), LegoFile::c_read) == FAILURE) {
 		goto done;
 	}
 
-	MxU32 version, status;
+	MxS32 version;
+	MxU32 status;
 	MxS16 count, actArea;
 	const char* lightPosition;
 
-	Read(&fileStorage, &version);
+	storage.Read(version);
 
 	if (version != 0x1000c) {
 		OmniError("Saved game version mismatch", 0);
 		goto done;
 	}
 
-	Read(&fileStorage, &m_unk0x24);
+	storage.Read(m_unk0x24);
+	storage.Read(actArea);
 
-	Read(&fileStorage, &actArea);
 	SetCurrentAct((Act) actArea);
-
-	Read(&fileStorage, &m_actorId);
+	storage.Read(m_actorId);
 	if (m_actorId) {
 		SetActor(m_actorId);
 	}
 
 	do {
-		status = ReadVariable(&fileStorage, variableTable);
+		status = ReadVariable(&storage, variableTable);
 		if (status == 1) {
 			goto done;
 		}
@@ -370,13 +372,13 @@ MxResult LegoGameState::Load(MxULong p_slot)
 		SetLightPosition(atoi(lightPosition));
 	}
 
-	if (CharacterManager()->Read(&fileStorage) == FAILURE) {
+	if (CharacterManager()->Read(&storage) == FAILURE) {
 		goto done;
 	}
-	if (PlantManager()->Read(&fileStorage) == FAILURE) {
+	if (PlantManager()->Read(&storage) == FAILURE) {
 		goto done;
 	}
-	if (BuildingManager()->Read(&fileStorage) == FAILURE) {
+	if (BuildingManager()->Read(&storage) == FAILURE) {
 		goto done;
 	}
 	if (DeleteState() != SUCCESS) {
@@ -384,14 +386,11 @@ MxResult LegoGameState::Load(MxULong p_slot)
 	}
 
 	char stateName[80];
-	Read(&fileStorage, &count);
+	storage.Read(count);
 
 	if (count) {
 		for (MxS16 i = 0; i < count; i++) {
-			MxS16 stateNameLength;
-			Read(&fileStorage, &stateNameLength);
-			Read(&fileStorage, stateName, (MxULong) stateNameLength);
-			stateName[stateNameLength] = 0;
+			storage.Read(stateName);
 
 			LegoState* state = GetState(stateName);
 			if (!state) {
@@ -402,11 +401,11 @@ MxResult LegoGameState::Load(MxULong p_slot)
 				}
 			}
 
-			state->Serialize(&fileStorage);
+			state->Serialize(&storage);
 		}
 	}
 
-	Read(&fileStorage, &actArea);
+	storage.Read(actArea);
 
 	if (m_currentAct == e_act1) {
 		m_unk0x42c = e_undefined;
@@ -537,10 +536,10 @@ void LegoGameState::SerializePlayersInfo(MxS16 p_flags)
 
 	if (fileStorage.Open(playersGSI.GetData(), p_flags) == SUCCESS) {
 		if (fileStorage.IsReadMode()) {
-			Read(&fileStorage, &m_playerCount);
+			fileStorage.Read(m_playerCount);
 		}
 		else if (fileStorage.IsWriteMode()) {
-			Write(&fileStorage, m_playerCount);
+			fileStorage.Write(m_playerCount);
 		}
 
 		for (MxS16 i = 0; i < m_playerCount; i++) {
@@ -1153,16 +1152,16 @@ LegoGameState::Username::Username()
 
 // FUNCTION: LEGO1 0x1003c690
 // FUNCTION: BETA10 0x10086c57
-MxResult LegoGameState::Username::Serialize(LegoStorage* p_storage)
+MxResult LegoGameState::Username::Serialize(LegoFile* p_file)
 {
-	if (p_storage->IsReadMode()) {
+	if (p_file->IsReadMode()) {
 		for (MxS16 i = 0; i < (MxS16) sizeOfArray(m_letters); i++) {
-			Read(p_storage, &m_letters[i]);
+			p_file->Read(m_letters[i]);
 		}
 	}
-	else if (p_storage->IsWriteMode()) {
+	else if (p_file->IsWriteMode()) {
 		for (MxS16 i = 0; i < (MxS16) sizeOfArray(m_letters); i++) {
-			Write(p_storage, m_letters[i]);
+			p_file->Write(m_letters[i]);
 		}
 	}
 
@@ -1182,28 +1181,28 @@ LegoGameState::Username& LegoGameState::Username::operator=(const Username& p_ot
 MxResult LegoGameState::ScoreItem::Serialize(LegoFile* p_file)
 {
 	if (p_file->IsReadMode()) {
-		Read(p_file, &m_totalScore);
+		p_file->Read(m_totalScore);
 
 		for (MxS32 i = 0; i < 5; i++) {
 			for (MxS32 j = 0; j < 5; j++) {
-				Read(p_file, &m_scores[i][j]);
+				p_file->Read(m_scores[i][j]);
 			}
 		}
 
 		m_name.Serialize(p_file);
-		Read(p_file, &m_unk0x2a);
+		p_file->Read(m_unk0x2a);
 	}
 	else if (p_file->IsWriteMode()) {
-		Write(p_file, m_totalScore);
+		p_file->Write(m_totalScore);
 
 		for (MxS32 i = 0; i < 5; i++) {
 			for (MxS32 j = 0; j < 5; j++) {
-				Write(p_file, m_scores[i][j]);
+				p_file->Write(m_scores[i][j]);
 			}
 		}
 
 		m_name.Serialize(p_file);
-		Write(p_file, m_unk0x2a);
+		p_file->Write(m_unk0x2a);
 	}
 
 	return SUCCESS;
@@ -1328,21 +1327,21 @@ LegoGameState::ScoreItem* LegoGameState::History::FUN_1003cc90(
 MxResult LegoGameState::History::Serialize(LegoFile* p_file)
 {
 	if (p_file->IsReadMode()) {
-		Read(p_file, &m_unk0x372);
-		Read(p_file, &m_count);
+		p_file->Read(m_unk0x372);
+		p_file->Read(m_count);
 
 		for (MxS16 i = 0; i < m_count; i++) {
 			MxS16 j;
-			Read(p_file, &j);
+			p_file->Read(j);
 			m_scores[i].Serialize(p_file);
 		}
 	}
 	else if (p_file->IsWriteMode()) {
-		Write(p_file, m_unk0x372);
-		Write(p_file, m_count);
+		p_file->Write(m_unk0x372);
+		p_file->Write(m_count);
 
 		for (MxS16 i = 0; i < m_count; i++) {
-			Write(p_file, i);
+			p_file->Write(i);
 			m_scores[i].Serialize(p_file);
 		}
 	}

LEGO1/lego/legoomni/src/common/legoutils.cpp

@@ -668,7 +668,7 @@ LegoNamedTexture* ReadNamedTexture(LegoFile* p_file)
 	LegoNamedTexture* namedTexture = NULL;
 	MxString string;
 
-	p_file->ReadString(string);
+	p_file->Read(string);
 
 	texture = new LegoTexture();
 	if (texture != NULL) {
@@ -743,7 +743,7 @@ void WriteDefaultTexture(LegoFile* p_file, const char* p_name)
 					LegoTexture texture;
 					texture.SetImage(image);
 
-					p_file->WriteString(name);
+					p_file->Write(MxString(name));
 					texture.Write(p_file);
 				}
 				else {
@@ -760,7 +760,7 @@ void WriteDefaultTexture(LegoFile* p_file, const char* p_name)
 // FUNCTION: LEGO1 0x1003f8a0
 void WriteNamedTexture(LegoFile* p_file, LegoNamedTexture* p_namedTexture)
 {
-	p_file->WriteString(*p_namedTexture->GetName());
+	p_file->Write(MxString(*p_namedTexture->GetName()));
 	p_namedTexture->GetTexture()->Write(p_file);
 }
 

LEGO1/lego/legoomni/src/worlds/gasstation.cpp

@@ -513,18 +513,18 @@ MxResult GasStationState::Serialize(LegoFile* p_file)
 	LegoState::Serialize(p_file);
 
 	if (p_file->IsWriteMode()) {
-		Write(p_file, m_pepperAction);
-		Write(p_file, m_mamaAction);
-		Write(p_file, m_papaAction);
-		Write(p_file, m_nickAction);
-		Write(p_file, m_lauraAction);
+		p_file->Write(m_pepperAction);
+		p_file->Write(m_mamaAction);
+		p_file->Write(m_papaAction);
+		p_file->Write(m_nickAction);
+		p_file->Write(m_lauraAction);
 	}
 	else if (p_file->IsReadMode()) {
-		Read(p_file, &m_pepperAction);
-		Read(p_file, &m_mamaAction);
-		Read(p_file, &m_papaAction);
-		Read(p_file, &m_nickAction);
-		Read(p_file, &m_lauraAction);
+		p_file->Read(m_pepperAction);
+		p_file->Read(m_mamaAction);
+		p_file->Read(m_papaAction);
+		p_file->Read(m_nickAction);
+		p_file->Read(m_lauraAction);
 	}
 
 	return SUCCESS;

LEGO1/lego/legoomni/src/worlds/hospital.cpp

@@ -694,25 +694,26 @@ HospitalState::HospitalState()
 }
 
 // FUNCTION: LEGO1 0x10076530
+// FUNCTION: BETA10 0x1002db26
 MxResult HospitalState::Serialize(LegoFile* p_file)
 {
 	LegoState::Serialize(p_file);
 
 	if (p_file->IsWriteMode()) {
-		Write(p_file, m_unk0x0c);
-		Write(p_file, m_unk0x0e);
-		Write(p_file, m_unk0x10);
-		Write(p_file, m_unk0x12);
-		Write(p_file, m_unk0x14);
-		Write(p_file, m_unk0x16);
+		p_file->Write(m_unk0x0c);
+		p_file->Write(m_unk0x0e);
+		p_file->Write(m_unk0x10);
+		p_file->Write(m_unk0x12);
+		p_file->Write(m_unk0x14);
+		p_file->Write(m_unk0x16);
 	}
 	else if (p_file->IsReadMode()) {
-		Read(p_file, &m_unk0x0c);
-		Read(p_file, &m_unk0x0e);
-		Read(p_file, &m_unk0x10);
-		Read(p_file, &m_unk0x12);
-		Read(p_file, &m_unk0x14);
-		Read(p_file, &m_unk0x16);
+		p_file->Read(m_unk0x0c);
+		p_file->Read(m_unk0x0e);
+		p_file->Read(m_unk0x10);
+		p_file->Read(m_unk0x12);
+		p_file->Read(m_unk0x14);
+		p_file->Read(m_unk0x16);
 	}
 
 	return SUCCESS;

LEGO1/lego/legoomni/src/worlds/isle.cpp

@@ -1337,82 +1337,83 @@ MxResult Act1State::Serialize(LegoFile* p_file)
 	m_racecarPlane.Serialize(p_file);
 
 	if (p_file->IsWriteMode()) {
-		if (m_helicopterPlane.IsPresent()) {
-			if (m_helicopterWindshield) {
-				WriteNamedTexture(p_file, m_helicopterWindshield);
-			}
-			else {
+		// TODO: Seems to match better when using strcmp directly instead of IsPresent
+		if (strcmp(m_helicopterPlane.m_name.GetData(), "")) {
+			if (!m_helicopterWindshield) {
 				WriteDefaultTexture(p_file, "chwind.gif");
 			}
-
-			if (m_helicopterJetLeft) {
-				WriteNamedTexture(p_file, m_helicopterJetLeft);
-			}
 			else {
+				WriteNamedTexture(p_file, m_helicopterWindshield);
+			}
+
+			if (!m_helicopterJetLeft) {
 				WriteDefaultTexture(p_file, "chjetl.gif");
 			}
-
-			if (m_helicopterJetRight) {
-				WriteNamedTexture(p_file, m_helicopterJetRight);
-			}
 			else {
+				WriteNamedTexture(p_file, m_helicopterJetLeft);
+			}
+
+			if (!m_helicopterJetRight) {
 				WriteDefaultTexture(p_file, "chjetr.gif");
 			}
+			else {
+				WriteNamedTexture(p_file, m_helicopterJetRight);
+			}
 		}
 
-		if (m_jetskiPlane.IsPresent()) {
-			if (m_jetskiFront) {
-				WriteNamedTexture(p_file, m_jetskiFront);
-			}
-			else {
+		if (strcmp(m_jetskiPlane.m_name.GetData(), "")) {
+			if (!m_jetskiFront) {
 				WriteDefaultTexture(p_file, "jsfrnt.gif");
 			}
-
-			if (m_jetskiWindshield) {
-				WriteNamedTexture(p_file, m_jetskiWindshield);
-			}
 			else {
+				WriteNamedTexture(p_file, m_jetskiFront);
+			}
+
+			if (!m_jetskiWindshield) {
 				WriteDefaultTexture(p_file, "jswnsh.gif");
 			}
+			else {
+				WriteNamedTexture(p_file, m_jetskiWindshield);
+			}
 		}
 
-		if (m_dunebuggyPlane.IsPresent()) {
-			if (m_dunebuggyFront) {
-				WriteNamedTexture(p_file, m_dunebuggyFront);
-			}
-			else {
+		if (strcmp(m_dunebuggyPlane.m_name.GetData(), "")) {
+			if (!m_dunebuggyFront) {
 				WriteDefaultTexture(p_file, "dbfrfn.gif");
 			}
+			else {
+				WriteNamedTexture(p_file, m_dunebuggyFront);
+			}
 		}
 
-		if (m_racecarPlane.IsPresent()) {
-			if (m_racecarFront) {
-				WriteNamedTexture(p_file, m_racecarFront);
-			}
-			else {
+		if (strcmp(m_racecarPlane.m_name.GetData(), "")) {
+			if (!m_racecarFront) {
 				WriteDefaultTexture(p_file, "rcfrnt.gif");
 			}
-
-			if (m_racecarBack) {
-				WriteNamedTexture(p_file, m_racecarBack);
-			}
 			else {
+				WriteNamedTexture(p_file, m_racecarFront);
+			}
+
+			if (!m_racecarBack) {
 				WriteDefaultTexture(p_file, "rcback.gif");
 			}
+			else {
+				WriteNamedTexture(p_file, m_racecarBack);
+			}
 
-			if (m_racecarTail) {
-				WriteNamedTexture(p_file, m_racecarTail);
+			if (!m_racecarTail) {
+				WriteDefaultTexture(p_file, "rctail.gif");
 			}
 			else {
-				WriteDefaultTexture(p_file, "rctail.gif");
+				WriteNamedTexture(p_file, m_racecarTail);
 			}
 		}
 
-		m_cptClickDialogue.WriteToFile(p_file);
-		Write(p_file, m_unk0x022);
+		p_file->Write(m_cptClickDialogue.m_nextIndex);
+		p_file->Write(m_unk0x022);
 	}
 	else if (p_file->IsReadMode()) {
-		if (m_helicopterPlane.IsPresent()) {
+		if (strcmp(m_helicopterPlane.m_name.GetData(), "")) {
 			m_helicopterWindshield = ReadNamedTexture(p_file);
 			if (m_helicopterWindshield == NULL) {
 				return FAILURE;
@@ -1429,7 +1430,7 @@ MxResult Act1State::Serialize(LegoFile* p_file)
 			}
 		}
 
-		if (m_jetskiPlane.IsPresent()) {
+		if (strcmp(m_jetskiPlane.m_name.GetData(), "")) {
 			m_jetskiFront = ReadNamedTexture(p_file);
 			if (m_jetskiFront == NULL) {
 				return FAILURE;
@@ -1441,14 +1442,14 @@ MxResult Act1State::Serialize(LegoFile* p_file)
 			}
 		}
 
-		if (m_dunebuggyPlane.IsPresent()) {
+		if (strcmp(m_dunebuggyPlane.m_name.GetData(), "")) {
 			m_dunebuggyFront = ReadNamedTexture(p_file);
 			if (m_dunebuggyFront == NULL) {
 				return FAILURE;
 			}
 		}
 
-		if (m_racecarPlane.IsPresent()) {
+		if (strcmp(m_racecarPlane.m_name.GetData(), "")) {
 			m_racecarFront = ReadNamedTexture(p_file);
 			if (m_racecarFront == NULL) {
 				return FAILURE;
@@ -1465,11 +1466,10 @@ MxResult Act1State::Serialize(LegoFile* p_file)
 			}
 		}
 
-		m_cptClickDialogue.ReadFromFile(p_file);
-		Read(p_file, &m_unk0x022);
+		p_file->Read(m_cptClickDialogue.m_nextIndex);
+		p_file->Read(m_unk0x022);
 	}
 
-	// TODO
 	return SUCCESS;
 }
 

LEGO1/lego/legoomni/src/worlds/police.cpp

@@ -208,15 +208,16 @@ PoliceState::PoliceState()
 }
 
 // FUNCTION: LEGO1 0x1005e990
+// FUNCTION: BETA10 0x100f08b0
 MxResult PoliceState::Serialize(LegoFile* p_file)
 {
 	LegoState::Serialize(p_file);
 
 	if (p_file->IsReadMode()) {
-		Read(p_file, &m_policeScript);
+		p_file->Read((MxS32&) m_policeScript);
 	}
 	else {
-		Write(p_file, m_policeScript);
+		p_file->Write((MxS32) m_policeScript);
 	}
 
 	return SUCCESS;