isledecomp/isle
1
0
Fork 0
mirror of https://github.com/isledecomp/isle.git synced 2026-01-28 18:51:16 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Fixes/matches/refactor

Browse Source
This commit is contained in:
Christian Semmler 2024-02-26 11:02:05 -05:00
parent 1e4c939db9
commit 5b53446ea5
13 changed files with 126 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
LEGO1/lego/legoomni/include/legogamestate.h
View File

@ -90,7 +90,7 @@ class LegoGameState {
// SIZE 0x0c
struct Username {
Username();
MxResult ReadWrite(LegoStorage* p_stream);
MxResult ReadWrite(LegoStorage* p_storage);
Username* operator=(const Username* p_other);
MxS16 m_letters[7]; // 0x00
@ -151,14 +151,14 @@ class LegoGameState {
void SetCurrentAct(Act p_currentAct);
void FindLoadedAct();
void SetVehicle(MxU8 p_actorId);
void SetActor(MxU8 p_actorId);
void FUN_10039940();
private:
void RegisterState(LegoState* p_state);
MxResult WriteVariable(LegoStorage* p_stream, MxVariableTable* p_from, const char* p_variableName);
MxResult WriteEndOfVariables(LegoStorage* p_stream);
MxS32 ReadVariable(LegoStorage* p_stream, MxVariableTable* p_to);
MxResult WriteVariable(LegoStorage* p_storage, MxVariableTable* p_from, const char* p_variableName);
MxResult WriteEndOfVariables(LegoStorage* p_storage);
MxS32 ReadVariable(LegoStorage* p_storage, MxVariableTable* p_to);
void SetColors();
void SetROIHandlerFunction();
@ -185,4 +185,7 @@ class LegoGameState {
MxBool ROIHandlerFunction(char* p_input, char* p_output, MxU32 p_copyLen);
// SYNTHETIC: LEGO1 0x1003c860
// LegoGameState::ScoreItem::ScoreItem
#endif // LEGOGAMESTATE_H

10
LEGO1/lego/legoomni/include/legoomni.h
View File

@ -216,7 +216,7 @@ class LegoOmni : public MxOmni {
ViewLODListManager* GetViewLODListManager() { return m_viewLODListManager; }
LegoWorld* GetCurrentWorld() { return m_currentWorld; }
LegoNavController* GetNavController() { return m_navController; }
IslePathActor* GetCurrentVehicle() { return m_currentVehicle; }
IslePathActor* GetCurrentActor() { return m_currentActor; }
LegoPlantManager* GetLegoPlantManager() { return m_plantManager; }
LegoAnimationManager* GetAnimationManager() { return m_animationManager; }
LegoBuildingManager* GetLegoBuildingManager() { return m_buildingManager; }
@ -228,7 +228,7 @@ class LegoOmni : public MxOmni {
LegoWorldList* GetWorldList() { return m_worldList; }
inline void SetNavController(LegoNavController* p_navController) { m_navController = p_navController; }
inline void SetCurrentVehicle(IslePathActor* p_currentVehicle) { m_currentVehicle = p_currentVehicle; }
inline void SetCurrentActor(IslePathActor* p_currentActor) { m_currentActor = p_currentActor; }
inline void SetCurrentWorld(LegoWorld* p_currentWorld) { m_currentWorld = p_currentWorld; }
inline void SetExit(MxBool p_exit) { m_exit = p_exit; }
@ -246,7 +246,7 @@ class LegoOmni : public MxOmni {
LegoWorld* m_currentWorld; // 0x7c
MxBool m_exit; // 0x80
LegoNavController* m_navController; // 0x84
IslePathActor* m_currentVehicle; // 0x88
IslePathActor* m_currentActor; // 0x88
LegoUnkSaveDataWriter* m_saveDataWriter; // 0x8c
LegoPlantManager* m_plantManager; // 0x90
LegoAnimationManager* m_animationManager; // 0x94
@ -272,7 +272,7 @@ LegoAnimationManager* AnimationManager();
LegoNavController* NavController();
LegoBuildingManager* BuildingManager();
LegoControlManager* ControlManager();
IslePathActor* CurrentVehicle();
IslePathActor* CurrentActor();
ViewManager* GetViewManager();
LegoPlantManager* PlantManager();
LegoWorld* CurrentWorld();
@ -281,7 +281,7 @@ LegoTextureContainer* TextureContainer();
ViewLODListManager* GetViewLODListManager();
void FUN_10015820(MxBool p_disable, MxU16 p_flags);
void SetROIUnknown0x0c(const char* p_name, undefined p_unk0x0c);
void SetCurrentVehicle(IslePathActor* p_currentVehicle);
void SetCurrentActor(IslePathActor* p_currentActor);
LegoWorld* FindWorld(const MxAtomId& p_atom, MxS32 p_entityid);
LegoROI* FindROI(const char* p_name);
MxDSAction& GetCurrentAction();

2
LEGO1/lego/legoomni/include/legounksavedatawriter.h
View File

@ -55,7 +55,7 @@ class LegoUnkSaveDataWriter {
public:
LegoUnkSaveDataWriter();
MxResult WriteSaveData3(LegoStorage* p_stream);
MxResult WriteSaveData3(LegoStorage* p_storage);
LegoROI* FUN_10083500(const char*, MxBool);
static void InitSaveData();

12
LEGO1/lego/legoomni/src/build/helicopter.cpp
View File

@ -67,9 +67,9 @@ void Helicopter::VTable0xe4()
if (GameState()->GetCurrentAct() == LegoGameState::e_act1) {
GameState()->SetCurrentArea(LegoGameState::e_unk60);
if (CurrentVehicle()) {
if (CurrentVehicle()->IsA("IslePathActor")) {
((IslePathActor*) CurrentVehicle())->VTable0xe8(0x37, TRUE, 7);
if (CurrentActor()) {
if (CurrentActor()->IsA("IslePathActor")) {
((IslePathActor*) CurrentActor())->VTable0xe8(0x37, TRUE, 7);
}
}
}
@ -102,9 +102,9 @@ MxU32 Helicopter::VTable0xcc()
AnimationManager()->FUN_1005f6d0(FALSE);
if (CurrentVehicle()) {
if (CurrentVehicle()->GetActorId() != GameState()->GetActorId()) {
CurrentVehicle()->VTable0xe4();
if (CurrentActor()) {
if (CurrentActor()->GetActorId() != GameState()->GetActorId()) {
CurrentActor()->VTable0xe4();
}
}

99
LEGO1/lego/legoomni/src/common/legogamestate.cpp
View File

@ -85,10 +85,10 @@ LegoGameState::LegoGameState()
m_savePath = NULL;
m_stateArray = NULL;
m_unk0x41c = -1;
m_unk0x26 = 0;
m_currentArea = e_noArea;
m_previousArea = e_noArea;
m_unk0x42c = e_noArea;
m_unk0x26 = 0;
m_isDirty = FALSE;
m_loadedAct = e_actNotFound;
SetCurrentAct(e_act1);
@ -96,7 +96,7 @@ LegoGameState::LegoGameState()
m_backgroundColor = new LegoBackgroundColor("backgroundcolor", "set 56 54 68");
VariableTable()->SetVariable(m_backgroundColor);
m_tempBackgroundColor = new LegoBackgroundColor("tempBackgroundcolor", "set 56 54 68");
m_tempBackgroundColor = new LegoBackgroundColor("tempBackgroundColor", "set 56 54 68");
VariableTable()->SetVariable(m_tempBackgroundColor);
m_fullScreenMovie = new LegoFullScreenMovie("fsmovie", "disable");
@ -126,28 +126,34 @@ LegoGameState::~LegoGameState()
}
// FUNCTION: LEGO1 0x10039780
void LegoGameState::SetVehicle(MxU8 p_actorId)
void LegoGameState::SetActor(MxU8 p_actorId)
{
if (p_actorId) {
m_actorId = p_actorId;
}
IslePathActor* oldVehicle = CurrentVehicle();
SetCurrentVehicle(NULL);
IslePathActor* newVehicle = new IslePathActor();
LegoROI* roi = UnkSaveDataWriter()->FUN_10083500(LegoActor::GetActorName(m_actorId), FALSE);
IslePathActor* oldActor = CurrentActor();
SetCurrentActor(NULL);
IslePathActor* newActor = new IslePathActor();
const char* actorName = LegoActor::GetActorName(m_actorId);
LegoROI* roi = UnkSaveDataWriter()->FUN_10083500(actorName, FALSE);
MxDSAction action;
action.SetAtomId(*g_isleScript);
action.SetObjectId(100000);
newVehicle->Create(action);
newVehicle->SetActorId(p_actorId);
newVehicle->SetROI(roi, FALSE, FALSE);
if (oldVehicle) {
newVehicle->GetROI()->FUN_100a58f0(oldVehicle->GetROI()->GetLocal2World());
newVehicle->SetUnknown88(oldVehicle->GetUnknown88());
delete oldVehicle;
newActor->Create(action);
newActor->SetActorId(p_actorId);
newActor->SetROI(roi, FALSE, FALSE);
if (oldActor) {
newActor->GetROI()->FUN_100a58f0(oldActor->GetROI()->GetLocal2World());
newActor->SetUnknown88(oldActor->GetUnknown88());
delete oldActor;
}
newVehicle->ClearFlag(0x2);
SetCurrentVehicle(newVehicle);
newActor->ClearFlag(0x02);
SetCurrentActor(newActor);
}
// STUB: LEGO1 0x10039940
@ -221,55 +227,58 @@ void LegoGameState::SetSavePath(char* p_savePath)
}
// FUNCTION: LEGO1 0x10039f70
MxResult LegoGameState::WriteVariable(LegoStorage* p_stream, MxVariableTable* p_from, const char* p_variableName)
MxResult LegoGameState::WriteVariable(LegoStorage* p_storage, MxVariableTable* p_from, const char* p_variableName)
{
MxResult result = FAILURE;
const char* variableValue = p_from->GetVariable(p_variableName);
if (variableValue) {
MxU8 length = strlen(p_variableName);
if (p_stream->Write((char*) &length, 1) == SUCCESS) {
if (p_stream->Write(p_variableName, length) == SUCCESS) {
if (p_storage->Write((char*) &length, 1) == SUCCESS) {
if (p_storage->Write(p_variableName, length) == SUCCESS) {
length = strlen(variableValue);
if (p_stream->Write((char*) &length, 1) == SUCCESS) {
result = p_stream->Write((char*) variableValue, length);
if (p_storage->Write((char*) &length, 1) == SUCCESS) {
result = p_storage->Write((char*) variableValue, length);
}
}
}
}
return result;
}
// FUNCTION: LEGO1 0x1003a020
MxResult LegoGameState::WriteEndOfVariables(LegoStorage* p_stream)
MxResult LegoGameState::WriteEndOfVariables(LegoStorage* p_storage)
{
MxU8 len = strlen(g_endOfVariables);
if (p_stream->Write(&len, 1) == SUCCESS) {
return p_stream->Write(g_endOfVariables, len);
if (p_storage->Write(&len, 1) == SUCCESS) {
return p_storage->Write(g_endOfVariables, len);
}
return FAILURE;
}
// 95% match, just some instruction ordering differences on the call to
// MxVariableTable::SetVariable at the end.
// FUNCTION: LEGO1 0x1003a080
MxS32 LegoGameState::ReadVariable(LegoStorage* p_stream, MxVariableTable* p_to)
MxS32 LegoGameState::ReadVariable(LegoStorage* p_storage, MxVariableTable* p_to)
{
MxS32 result = 1;
MxU8 length;
if (p_stream->Read((char*) &length, 1) == SUCCESS) {
if (p_storage->Read((char*) &length, 1) == SUCCESS) {
char nameBuffer[256];
if (p_stream->Read(nameBuffer, length) == SUCCESS) {
if (p_storage->Read(nameBuffer, length) == SUCCESS) {
nameBuffer[length] = '\0';
if (strcmp(nameBuffer, g_endOfVariables) == 0) {
// 2 -> "This was the last entry, done reading."
result = 2;
}
else {
if (p_stream->Read((char*) &length, 1) == SUCCESS) {
if (p_storage->Read((char*) &length, 1) == SUCCESS) {
char valueBuffer[256];
if (p_stream->Read(valueBuffer, length) == SUCCESS) {
if (p_storage->Read(valueBuffer, length) == SUCCESS) {
result = 0;
valueBuffer[length] = '\0';
p_to->SetVariable(nameBuffer, valueBuffer);
@ -278,6 +287,7 @@ MxS32 LegoGameState::ReadVariable(LegoStorage* p_stream, MxVariableTable* p_to)
}
}
}
return result;
}
@ -590,7 +600,7 @@ void LegoGameState::SwitchArea(Area p_area)
case e_garadoor:
LoadIsle();
VariableTable()->SetVariable("VISIBILITY", "Hide Gas");
CurrentVehicle()->ResetWorldTransform(FALSE);
CurrentActor()->ResetWorldTransform(FALSE);
NavController()->SetLocation(0x3b);
VideoManager()->Get3DManager()->SetFrustrum(90, 0.1f, 250.0f);
InvokeAction(Extra::ActionType::e_start, *g_isleScript, 1160, NULL);
@ -603,10 +613,10 @@ void LegoGameState::SwitchArea(Area p_area)
}
else {
SetCameraControllerFromIsle();
CurrentVehicle()->ResetWorldTransform(TRUE);
CurrentActor()->ResetWorldTransform(TRUE);
AnimationManager()->FUN_1005f0b0();
}
CurrentVehicle()->VTable0xe8(p_area, TRUE, 7);
CurrentActor()->VTable0xe8(p_area, TRUE, 7);
break;
}
case e_hospital:
@ -616,9 +626,9 @@ void LegoGameState::SwitchArea(Area p_area)
case e_unk33:
LoadIsle();
SetCameraControllerFromIsle();
CurrentVehicle()->ResetWorldTransform(TRUE);
CurrentActor()->ResetWorldTransform(TRUE);
AnimationManager()->FUN_1005f0b0();
CurrentVehicle()->VTable0xe8(p_area, TRUE, 7);
CurrentActor()->VTable0xe8(p_area, TRUE, 7);
break;
case e_police:
VideoManager()->SetUnk0x554(TRUE);
@ -683,9 +693,10 @@ void LegoGameState::SwitchArea(Area p_area)
// FUNCTION: LEGO1 0x1003ba90
void LegoGameState::SetColors()
{
MxVariableTable* variables = VariableTable();
for (int i = 0; i < _countof(g_colorSaveData); i++) {
variables->SetVariable(g_colorSaveData[i].m_targetName, g_colorSaveData[i].m_colorName);
MxVariableTable* variableTable = VariableTable();
for (MxS32 i = 0; i < _countof(g_colorSaveData); i++) {
variableTable->SetVariable(g_colorSaveData[i].m_targetName, g_colorSaveData[i].m_colorName);
}
}
@ -768,22 +779,24 @@ void LegoGameState::RegisterState(LegoState* p_state)
// FUNCTION: LEGO1 0x1003c670
LegoGameState::Username::Username()
{
memset(m_letters, 0, sizeof(m_letters));
memset(m_letters, -1, sizeof(m_letters));
}
// FUNCTION: LEGO1 0x1003c690
MxResult LegoGameState::Username::ReadWrite(LegoStorage* p_stream)
MxResult LegoGameState::Username::ReadWrite(LegoStorage* p_storage)
{
if (p_stream->IsReadMode()) {
if (p_storage->IsReadMode()) {
for (MxS16 i = 0; i < 7; i++) {
p_stream->Read(&m_letters[i], 2);
p_storage->Read(&m_letters[i], sizeof(m_letters[i]));
}
}
else if (p_stream->IsWriteMode()) {
else if (p_storage->IsWriteMode()) {
for (MxS16 i = 0; i < 7; i++) {
p_stream->Write(&m_letters[i], 2);
MxS16 letter = m_letters[i];
p_storage->Write(&letter, sizeof(letter));
}
}
return SUCCESS;
}

23
LEGO1/lego/legoomni/src/common/legounksavedatawriter.cpp
View File

@ -41,7 +41,7 @@ void LegoUnkSaveDataWriter::FUN_100832a0()
}
// FUNCTION: LEGO1 0x10083310
MxResult LegoUnkSaveDataWriter::WriteSaveData3(LegoStorage* p_stream)
MxResult LegoUnkSaveDataWriter::WriteSaveData3(LegoStorage* p_storage)
{
MxResult result = FAILURE;
@ -51,34 +51,34 @@ MxResult LegoUnkSaveDataWriter::WriteSaveData3(LegoStorage* p_stream)
const LegoSaveDataEntry3* end = &g_saveData3[66];
while (TRUE) {
if (p_stream->Write(&entry->m_savePart1, 4) != SUCCESS) {
if (p_storage->Write(&entry->m_savePart1, 4) != SUCCESS) {
break;
}
if (p_stream->Write(&entry->m_savePart2, 4) != SUCCESS) {
if (p_storage->Write(&entry->m_savePart2, 4) != SUCCESS) {
break;
}
if (p_stream->Write(&entry->m_savePart3, 1) != SUCCESS) {
if (p_storage->Write(&entry->m_savePart3, 1) != SUCCESS) {
break;
}
if (p_stream->Write(&entry->m_currentFrame, 1) != SUCCESS) {
if (p_storage->Write(&entry->m_currentFrame, 1) != SUCCESS) {
break;
}
if (p_stream->Write(&entry->m_savePart5, 1) != SUCCESS) {
if (p_storage->Write(&entry->m_savePart5, 1) != SUCCESS) {
break;
}
if (p_stream->Write(&entry->m_savePart6, 1) != SUCCESS) {
if (p_storage->Write(&entry->m_savePart6, 1) != SUCCESS) {
break;
}
if (p_stream->Write(&entry->m_savePart7, 1) != SUCCESS) {
if (p_storage->Write(&entry->m_savePart7, 1) != SUCCESS) {
break;
}
if (p_stream->Write(&entry->m_savePart8, 1) != SUCCESS) {
if (p_storage->Write(&entry->m_savePart8, 1) != SUCCESS) {
break;
}
if (p_stream->Write(&entry->m_savePart9, 1) != SUCCESS) {
if (p_storage->Write(&entry->m_savePart9, 1) != SUCCESS) {
break;
}
if (p_stream->Write(&entry->m_savePart10, 1) != SUCCESS) {
if (p_storage->Write(&entry->m_savePart10, 1) != SUCCESS) {
break;
}
if (++entry >= end) {
@ -86,6 +86,7 @@ MxResult LegoUnkSaveDataWriter::WriteSaveData3(LegoStorage* p_stream)
break;
}
}
return result;
}

6
LEGO1/lego/legoomni/src/entity/legoworld.cpp
View File

@ -588,10 +588,10 @@ void LegoWorld::Enable(MxBool p_enable)
else if (!p_enable && m_set0xd0.empty()) {
MxPresenter* presenter;
LegoPathController* controller;
IslePathActor* vehicle = CurrentVehicle();
IslePathActor* actor = CurrentActor();
if (vehicle) {
FUN_1001fc80(vehicle);
if (actor) {
FUN_1001fc80(actor);
}
AnimationManager()->FUN_1005ee80(FALSE);

8
LEGO1/lego/legoomni/src/infocenter/infocenter.cpp
View File

@ -201,7 +201,7 @@ MxLong Infocenter::HandleEndAction(MxEndActionNotificationParam& p_param)
if (!m_unk0x1d4) {
PlayMusic(JukeBox::e_informationCenter);
GameState()->SetVehicle(m_selectedCharacter);
GameState()->SetActor(m_selectedCharacter);
switch (m_selectedCharacter) {
case e_pepper:
@ -303,7 +303,7 @@ MxLong Infocenter::HandleEndAction(MxEndActionNotificationParam& p_param)
case 5:
if (action->GetObjectId() == m_currentInfomainScript) {
if (GameState()->GetCurrentAct() != LegoGameState::e_act3 && m_selectedCharacter != e_noCharacter) {
GameState()->SetVehicle(m_selectedCharacter);
GameState()->SetActor(m_selectedCharacter);
}
TransitionManager()->StartTransition(MxTransitionManager::e_pixelation, 50, FALSE, FALSE);
m_infocenterState->SetUnknown0x74(14);
@ -734,7 +734,7 @@ MxU8 Infocenter::HandleButtonUp(MxS32 p_x, MxS32 p_y)
switch (m_mapAreas[m_unk0x1c8].m_unk0x04) {
case 3:
GameState()->SetVehicle(m_selectedCharacter);
GameState()->SetActor(m_selectedCharacter);
switch (m_selectedCharacter) {
case e_pepper:
@ -1292,7 +1292,7 @@ void Infocenter::Reset()
InitializeBitmaps();
m_selectedCharacter = e_pepper;
GameState()->SetVehicle(e_pepper);
GameState()->SetActor(e_pepper);
HelicopterState* state = (HelicopterState*) GameState()->GetState("HelicopterState");

6
LEGO1/lego/legoomni/src/isle/isle.cpp
View File

@ -46,8 +46,8 @@ Isle::~Isle()
InputManager()->ClearWorld();
}
if (CurrentVehicle() != NULL) {
VTable0x6c(CurrentVehicle());
if (CurrentActor() != NULL) {
VTable0x6c(CurrentActor());
}
NotificationManager()->Unregister(this);
@ -121,7 +121,7 @@ MxLong Isle::Notify(MxParam& p_param)
case c_notificationType18:
switch (m_act1state->GetUnknown18()) {
case 4:
result = CurrentVehicle()->Notify(p_param);
result = CurrentActor()->Notify(p_param);
break;
case 8:
result = m_towtrack->Notify(p_param);

4
LEGO1/lego/legoomni/src/isle/jukeboxentity.cpp
View File

@ -29,8 +29,8 @@ MxLong JukeBoxEntity::Notify(MxParam& p_param)
return 1;
}
if (CurrentVehicle()->GetActorId() != GameState()->GetActorId()) {
CurrentVehicle()->VTable0xe4();
if (CurrentActor()->GetActorId() != GameState()->GetActorId()) {
CurrentActor()->VTable0xe4();
}
((Isle*) FindWorld(*g_isleScript, 0))->SetUnknown13c(0x35);

10
LEGO1/lego/legoomni/src/main/legoomni.cpp
View File

@ -179,9 +179,9 @@ LegoNavController* NavController()
}
// FUNCTION: LEGO1 0x10015790
IslePathActor* CurrentVehicle()
IslePathActor* CurrentActor()
{
return LegoOmni::GetInstance()->GetCurrentVehicle();
return LegoOmni::GetInstance()->GetCurrentActor();
}
// FUNCTION: LEGO1 0x100157a0
@ -249,9 +249,9 @@ void SetROIUnknown0x0c(const char* p_name, undefined p_unk0x0c)
}
// FUNCTION: LEGO1 0x10015880
void SetCurrentVehicle(IslePathActor* p_currentVehicle)
void SetCurrentActor(IslePathActor* p_currentActor)
{
LegoOmni::GetInstance()->SetCurrentVehicle(p_currentVehicle);
LegoOmni::GetInstance()->SetCurrentActor(p_currentActor);
}
// FUNCTION: LEGO1 0x100158c0
@ -484,7 +484,7 @@ void LegoOmni::Init()
m_worldList = NULL;
m_currentWorld = NULL;
m_exit = FALSE;
m_currentVehicle = NULL;
m_currentActor = NULL;
m_saveDataWriter = NULL;
m_plantManager = NULL;
m_gameState = NULL;

2
LEGO1/lego/legoomni/src/police/policestate.cpp
View File

@ -44,7 +44,7 @@ void PoliceState::FUN_1005ea40()
return;
}
switch (CurrentVehicle()->GetActorId()) {
switch (CurrentActor()->GetActorId()) {
case 4:
policeScript = Police::PoliceScript::c_lauraAnim;
m_policeScript = policeScript;

40
LEGO1/lego/legoomni/src/towtrack/towtrackmissionstate.cpp
View File

@ -28,47 +28,47 @@ MxResult TowTrackMissionState::VTable0x1c(LegoFile* p_legoFile)
}
if (p_legoFile->IsReadMode()) {
p_legoFile->Read(&m_unk0x12, sizeof(MxU16));
p_legoFile->Read(&m_unk0x14, sizeof(MxU16));
p_legoFile->Read(&m_unk0x16, sizeof(MxU16));
p_legoFile->Read(&m_unk0x18, sizeof(MxU16));
p_legoFile->Read(&m_unk0x1a, sizeof(MxU16));
p_legoFile->Read(&m_unk0x1c, sizeof(MxU16));
p_legoFile->Read(&m_color1, sizeof(MxU16));
p_legoFile->Read(&m_color2, sizeof(MxU16));
p_legoFile->Read(&m_color3, sizeof(MxU16));
p_legoFile->Read(&m_color4, sizeof(MxU16));
p_legoFile->Read(&m_unk0x12, sizeof(m_unk0x12));
p_legoFile->Read(&m_unk0x14, sizeof(m_unk0x14));
p_legoFile->Read(&m_unk0x16, sizeof(m_unk0x16));
p_legoFile->Read(&m_unk0x18, sizeof(m_unk0x18));
p_legoFile->Read(&m_unk0x1a, sizeof(m_unk0x1a));
p_legoFile->Read(&m_unk0x1c, sizeof(m_unk0x1c));
p_legoFile->Read(&m_color1, sizeof(m_color1));
p_legoFile->Read(&m_color2, sizeof(m_color2));
p_legoFile->Read(&m_color3, sizeof(m_color3));
p_legoFile->Read(&m_color4, sizeof(m_color4));
}
else if (p_legoFile->IsWriteMode()) {
MxU16 write = m_unk0x12;
p_legoFile->Write(&write, sizeof(MxU16));
p_legoFile->Write(&write, sizeof(m_unk0x12));
write = m_unk0x14;
p_legoFile->Write(&write, sizeof(MxU16));
p_legoFile->Write(&write, sizeof(m_unk0x12));
write = m_unk0x16;
p_legoFile->Write(&write, sizeof(MxU16));
p_legoFile->Write(&write, sizeof(m_unk0x12));
write = m_unk0x18;
p_legoFile->Write(&write, sizeof(MxU16));
p_legoFile->Write(&write, sizeof(m_unk0x12));
write = m_unk0x1a;
p_legoFile->Write(&write, sizeof(MxU16));
p_legoFile->Write(&write, sizeof(m_unk0x12));
write = m_unk0x1c;
p_legoFile->Write(&write, sizeof(MxU16));
p_legoFile->Write(&write, sizeof(m_unk0x12));
write = m_color1;
p_legoFile->Write(&write, sizeof(MxU16));
p_legoFile->Write(&write, sizeof(m_unk0x12));
write = m_color2;
p_legoFile->Write(&write, sizeof(MxU16));
p_legoFile->Write(&write, sizeof(m_unk0x12));
write = m_color3;
p_legoFile->Write(&write, sizeof(MxU16));
p_legoFile->Write(&write, sizeof(m_unk0x12));
write = m_color4;
p_legoFile->Write(&write, sizeof(MxU16));
p_legoFile->Write(&write, sizeof(m_unk0x12));
}
return SUCCESS;